2 * common OpenGL routines
4 * copyleft (C) 2005 Reimar Döffinger <Reimar.Doeffinger@stud.uni-karlsruhe.de>
5 * Special thanks go to the xine team and Matthias Hopf, whose video_out_opengl.c
6 * gave me lots of good ideas.
8 * This file is part of MPlayer.
10 * MPlayer is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * MPlayer is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License along
21 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
22 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
27 * \brief OpenGL helper functions used by vo_gl.c and vo_gl2.c
35 #include "gl_common.h"
36 #include "libavutil/common.h"
39 * \defgroup glextfunctions OpenGL extension functions
41 * the pointers to these functions are acquired when the OpenGL
45 void (APIENTRY
*GenBuffers
)(GLsizei
, GLuint
*);
46 void (APIENTRY
*DeleteBuffers
)(GLsizei
, const GLuint
*);
47 void (APIENTRY
*BindBuffer
)(GLenum
, GLuint
);
48 GLvoid
* (APIENTRY
*MapBuffer
)(GLenum
, GLenum
);
49 GLboolean (APIENTRY
*UnmapBuffer
)(GLenum
);
50 void (APIENTRY
*BufferData
)(GLenum
, intptr_t, const GLvoid
*, GLenum
);
51 void (APIENTRY
*CombinerParameterfv
)(GLenum
, const GLfloat
*);
52 void (APIENTRY
*CombinerParameteri
)(GLenum
, GLint
);
53 void (APIENTRY
*CombinerInput
)(GLenum
, GLenum
, GLenum
, GLenum
, GLenum
,
55 void (APIENTRY
*CombinerOutput
)(GLenum
, GLenum
, GLenum
, GLenum
, GLenum
,
56 GLenum
, GLenum
, GLboolean
, GLboolean
,
58 void (APIENTRY
*BeginFragmentShader
)(void);
59 void (APIENTRY
*EndFragmentShader
)(void);
60 void (APIENTRY
*SampleMap
)(GLuint
, GLuint
, GLenum
);
61 void (APIENTRY
*ColorFragmentOp2
)(GLenum
, GLuint
, GLuint
, GLuint
, GLuint
,
62 GLuint
, GLuint
, GLuint
, GLuint
, GLuint
);
63 void (APIENTRY
*ColorFragmentOp3
)(GLenum
, GLuint
, GLuint
, GLuint
, GLuint
,
64 GLuint
, GLuint
, GLuint
, GLuint
, GLuint
,
65 GLuint
, GLuint
, GLuint
);
66 void (APIENTRY
*SetFragmentShaderConstant
)(GLuint
, const GLfloat
*);
67 void (APIENTRY
*ActiveTexture
)(GLenum
);
68 void (APIENTRY
*BindTexture
)(GLenum
, GLuint
);
69 void (APIENTRY
*MultiTexCoord2f
)(GLenum
, GLfloat
, GLfloat
);
70 void (APIENTRY
*GenPrograms
)(GLsizei
, GLuint
*);
71 void (APIENTRY
*DeletePrograms
)(GLsizei
, const GLuint
*);
72 void (APIENTRY
*BindProgram
)(GLenum
, GLuint
);
73 void (APIENTRY
*ProgramString
)(GLenum
, GLenum
, GLsizei
, const GLvoid
*);
74 void (APIENTRY
*GetProgramiv
)(GLenum
, GLenum
, GLint
*);
75 void (APIENTRY
*ProgramEnvParameter4f
)(GLenum
, GLuint
, GLfloat
, GLfloat
,
77 int (APIENTRY
*SwapInterval
)(int);
78 void (APIENTRY
*TexImage3D
)(GLenum
, GLint
, GLenum
, GLsizei
, GLsizei
, GLsizei
,
79 GLint
, GLenum
, GLenum
, const GLvoid
*);
80 void* (APIENTRY
*AllocateMemoryMESA
)(void *, int, size_t, float, float, float);
81 void (APIENTRY
*FreeMemoryMESA
)(void *, int, void *);
82 /** \} */ // end of glextfunctions group
84 //! \defgroup glgeneral OpenGL general helper functions
86 //! \defgroup glcontext OpenGL context management helper functions
88 //! \defgroup gltexture OpenGL texture handling helper functions
90 //! \defgroup glconversion OpenGL conversion helper functions
92 static GLint hqtexfmt
;
95 * \brief adjusts the GL_UNPACK_ALIGNMENT to fit the stride.
96 * \param stride number of bytes per line for which alignment should fit.
99 void glAdjustAlignment(int stride
) {
103 else if (stride
% 4 == 0)
105 else if (stride
% 2 == 0)
109 glPixelStorei (GL_UNPACK_ALIGNMENT
, gl_alignment
);
112 struct gl_name_map_struct
{
118 #define MAP(a) {a, #a}
119 //! mapping table for the glValName function
120 static const struct gl_name_map_struct gl_name_map
[] = {
122 MAP(GL_R3_G3_B2
), MAP(GL_RGB4
), MAP(GL_RGB5
), MAP(GL_RGB8
),
123 MAP(GL_RGB10
), MAP(GL_RGB12
), MAP(GL_RGB16
), MAP(GL_RGBA2
),
124 MAP(GL_RGBA4
), MAP(GL_RGB5_A1
), MAP(GL_RGBA8
), MAP(GL_RGB10_A2
),
125 MAP(GL_RGBA12
), MAP(GL_RGBA16
), MAP(GL_LUMINANCE8
),
128 MAP(GL_RGB
), MAP(GL_RGBA
), MAP(GL_RED
), MAP(GL_GREEN
), MAP(GL_BLUE
),
129 MAP(GL_ALPHA
), MAP(GL_LUMINANCE
), MAP(GL_LUMINANCE_ALPHA
),
132 MAP(GL_BGR
), MAP(GL_BGRA
),
135 MAP(GL_BYTE
), MAP(GL_UNSIGNED_BYTE
), MAP(GL_SHORT
), MAP(GL_UNSIGNED_SHORT
),
136 MAP(GL_INT
), MAP(GL_UNSIGNED_INT
), MAP(GL_FLOAT
), MAP(GL_DOUBLE
),
137 MAP(GL_2_BYTES
), MAP(GL_3_BYTES
), MAP(GL_4_BYTES
),
139 MAP(GL_UNSIGNED_BYTE_3_3_2
), MAP(GL_UNSIGNED_BYTE_2_3_3_REV
),
140 MAP(GL_UNSIGNED_SHORT_5_6_5
), MAP(GL_UNSIGNED_SHORT_5_6_5_REV
),
141 MAP(GL_UNSIGNED_SHORT_4_4_4_4
), MAP(GL_UNSIGNED_SHORT_4_4_4_4_REV
),
142 MAP(GL_UNSIGNED_SHORT_5_5_5_1
), MAP(GL_UNSIGNED_SHORT_1_5_5_5_REV
),
143 MAP(GL_UNSIGNED_INT_8_8_8_8
), MAP(GL_UNSIGNED_INT_8_8_8_8_REV
),
144 MAP(GL_UNSIGNED_INT_10_10_10_2
), MAP(GL_UNSIGNED_INT_2_10_10_10_REV
),
150 * \brief return the name of an OpenGL constant
151 * \param value the constant
152 * \return name of the constant or "Unknown format!"
155 const char *glValName(GLint value
)
159 while (gl_name_map
[i
].name
) {
160 if (gl_name_map
[i
].value
== value
)
161 return gl_name_map
[i
].name
;
164 return "Unknown format!";
167 //! always return this format as internal texture format in glFindFormat
168 #define TEXTUREFORMAT_ALWAYS GL_RGB8
169 #undef TEXTUREFORMAT_ALWAYS
172 * \brief find the OpenGL settings coresponding to format.
174 * All parameters may be NULL.
175 * \param fmt MPlayer format to analyze.
176 * \param bpp [OUT] bits per pixel of that format.
177 * \param gl_texfmt [OUT] internal texture format that fits the
178 * image format, not necessarily the best for performance.
179 * \param gl_format [OUT] OpenGL format for this image format.
180 * \param gl_type [OUT] OpenGL type for this image format.
181 * \return 1 if format is supported by OpenGL, 0 if not.
184 int glFindFormat(uint32_t fmt
, int *bpp
, GLint
*gl_texfmt
,
185 GLenum
*gl_format
, GLenum
*gl_type
)
191 if (!bpp
) bpp
= &dummy1
;
192 if (!gl_texfmt
) gl_texfmt
= &dummy3
;
193 if (!gl_format
) gl_format
= &dummy2
;
194 if (!gl_type
) gl_type
= &dummy2
;
196 *bpp
= IMGFMT_IS_BGR(fmt
)?IMGFMT_BGR_DEPTH(fmt
):IMGFMT_RGB_DEPTH(fmt
);
201 *gl_type
= GL_UNSIGNED_BYTE
;
205 *gl_format
= GL_RGBA
;
206 *gl_type
= GL_UNSIGNED_BYTE
;
209 supported
= 0; // no native YV12 support
214 *gl_format
= GL_LUMINANCE
;
215 *gl_type
= GL_UNSIGNED_BYTE
;
219 *gl_texfmt
= GL_YCBCR_MESA
;
221 *gl_format
= GL_YCBCR_MESA
;
222 *gl_type
= fmt
== IMGFMT_UYVY
? GL_UNSIGNED_SHORT_8_8
: GL_UNSIGNED_SHORT_8_8_REV
;
225 // we do not support palettized formats, although the format the
226 // swscale produces works
229 gl_type
= GL_UNSIGNED_BYTE_2_3_3_REV
;
233 *gl_format
= GL_RGBA
;
234 *gl_type
= GL_UNSIGNED_SHORT_1_5_5_5_REV
;
238 *gl_type
= GL_UNSIGNED_SHORT_5_6_5_REV
;
242 // special case as red and blue have a differen number of bits.
243 // GL_BGR and GL_UNSIGNED_BYTE_3_3_2 isn't supported at least
244 // by nVidia drivers, and in addition would give more bits to
245 // blue than to red, which isn't wanted
247 gl_type
= GL_UNSIGNED_BYTE_3_3_2
;
251 *gl_format
= GL_BGRA
;
252 *gl_type
= GL_UNSIGNED_SHORT_1_5_5_5_REV
;
256 *gl_type
= GL_UNSIGNED_SHORT_5_6_5
;
260 *gl_type
= GL_UNSIGNED_BYTE
;
264 *gl_format
= GL_BGRA
;
265 *gl_type
= GL_UNSIGNED_BYTE
;
269 *gl_format
= GL_RGBA
;
270 *gl_type
= GL_UNSIGNED_BYTE
;
273 #ifdef TEXTUREFORMAT_ALWAYS
274 *gl_texfmt
= TEXTUREFORMAT_ALWAYS
;
279 static void *setNull(const GLubyte
*s
) {
286 const char *funcnames
[7];
289 static const extfunc_desc_t extfuncs
[] = {
290 {&GenBuffers
, NULL
, {"glGenBuffers", "glGenBuffersARB", NULL
}},
291 {&DeleteBuffers
, NULL
, {"glDeleteBuffers", "glDeleteBuffersARB", NULL
}},
292 {&BindBuffer
, NULL
, {"glBindBuffer", "glBindBufferARB", NULL
}},
293 {&MapBuffer
, NULL
, {"glMapBuffer", "glMapBufferARB", NULL
}},
294 {&UnmapBuffer
, NULL
, {"glUnmapBuffer", "glUnmapBufferARB", NULL
}},
295 {&BufferData
, NULL
, {"glBufferData", "glBufferDataARB", NULL
}},
296 {&CombinerParameterfv
, "NV_register_combiners", {"glCombinerParameterfv", "glCombinerParameterfvNV", NULL
}},
297 {&CombinerParameteri
, "NV_register_combiners", {"glCombinerParameteri", "glCombinerParameteriNV", NULL
}},
298 {&CombinerInput
, "NV_register_combiners", {"glCombinerInput", "glCombinerInputNV", NULL
}},
299 {&CombinerOutput
, "NV_register_combiners", {"glCombinerOutput", "glCombinerOutputNV", NULL
}},
300 {&BeginFragmentShader
, "ATI_fragment_shader", {"glBeginFragmentShaderATI", NULL
}},
301 {&EndFragmentShader
, "ATI_fragment_shader", {"glEndFragmentShaderATI", NULL
}},
302 {&SampleMap
, "ATI_fragment_shader", {"glSampleMapATI", NULL
}},
303 {&ColorFragmentOp2
, "ATI_fragment_shader", {"glColorFragmentOp2ATI", NULL
}},
304 {&ColorFragmentOp3
, "ATI_fragment_shader", {"glColorFragmentOp3ATI", NULL
}},
305 {&SetFragmentShaderConstant
, "ATI_fragment_shader", {"glSetFragmentShaderConstantATI", NULL
}},
306 {&ActiveTexture
, NULL
, {"glActiveTexture", "glActiveTextureARB", NULL
}},
307 {&BindTexture
, NULL
, {"glBindTexture", "glBindTextureARB", "glBindTextureEXT", NULL
}},
308 {&MultiTexCoord2f
, NULL
, {"glMultiTexCoord2f", "glMultiTexCoord2fARB", NULL
}},
309 {&GenPrograms
, "_program", {"glGenProgramsARB", NULL
}},
310 {&DeletePrograms
, "_program", {"glDeleteProgramsARB", NULL
}},
311 {&BindProgram
, "_program", {"glBindProgramARB", NULL
}},
312 {&ProgramString
, "_program", {"glProgramStringARB", NULL
}},
313 {&GetProgramiv
, "_program", {"glGetProgramivARB", NULL
}},
314 {&ProgramEnvParameter4f
, "_program", {"glProgramEnvParameter4fARB", NULL
}},
315 {&SwapInterval
, "_swap_control", {"glXSwapInterval", "glXSwapIntervalEXT", "glXSwapIntervalSGI", "wglSwapInterval", "wglSwapIntervalEXT", "wglSwapIntervalSGI", NULL
}},
316 {&TexImage3D
, NULL
, {"glTexImage3D", NULL
}},
317 {&AllocateMemoryMESA
, "GLX_MESA_allocate_memory", {"glXAllocateMemoryMESA", NULL
}},
318 {&FreeMemoryMESA
, "GLX_MESA_allocate_memory", {"glXFreeMemoryMESA", NULL
}},
323 * \brief find the function pointers of some useful OpenGL extensions
324 * \param getProcAddress function to resolve function names, may be NULL
325 * \param ext2 an extra extension string
327 static void getFunctions(void *(*getProcAddress
)(const GLubyte
*),
329 const extfunc_desc_t
*dsc
;
330 const char *extensions
= (const char *)glGetString(GL_EXTENSIONS
);
332 if (!extensions
) extensions
= "";
333 if (!ext2
) ext2
= "";
334 allexts
= malloc(strlen(extensions
) + strlen(ext2
) + 2);
335 strcpy(allexts
, extensions
);
336 strcat(allexts
, " ");
337 strcat(allexts
, ext2
);
338 mp_msg(MSGT_VO
, MSGL_V
, "OpenGL extensions string:\n%s\n", allexts
);
340 getProcAddress
= setNull
;
341 for (dsc
= extfuncs
; dsc
->funcptr
; dsc
++) {
344 if (!dsc
->extstr
|| strstr(allexts
, dsc
->extstr
)) {
345 for (i
= 0; !ptr
&& dsc
->funcnames
[i
]; i
++)
346 ptr
= getProcAddress((const GLubyte
*)dsc
->funcnames
[i
]);
348 *(void **)dsc
->funcptr
= ptr
;
350 if (strstr(allexts
, "_texture_float"))
351 hqtexfmt
= GL_RGB32F
;
352 else if (strstr(allexts
, "NV_float_buffer"))
353 hqtexfmt
= GL_FLOAT_RGB32_NV
;
360 * \brief create a texture and set some defaults
361 * \param target texture taget, usually GL_TEXTURE_2D
362 * \param fmt internal texture format
363 * \param format texture host data format
364 * \param type texture host data type
365 * \param filter filter used for scaling, e.g. GL_LINEAR
366 * \param w texture width
367 * \param h texture height
368 * \param val luminance value to fill texture with
371 void glCreateClearTex(GLenum target
, GLenum fmt
, GLenum format
, GLenum type
, GLint filter
,
372 int w
, int h
, unsigned char val
) {
373 GLfloat fval
= (GLfloat
)val
/ 255.0;
374 GLfloat border
[4] = {fval
, fval
, fval
, fval
};
375 int stride
= w
* glFmt2bpp(format
, type
);
378 init
= malloc(stride
* h
);
379 memset(init
, val
, stride
* h
);
380 glAdjustAlignment(stride
);
381 glPixelStorei(GL_UNPACK_ROW_LENGTH
, w
);
382 glTexImage2D(target
, 0, fmt
, w
, h
, 0, format
, type
, init
);
383 glTexParameterf(target
, GL_TEXTURE_PRIORITY
, 1.0);
384 glTexParameteri(target
, GL_TEXTURE_MIN_FILTER
, filter
);
385 glTexParameteri(target
, GL_TEXTURE_MAG_FILTER
, filter
);
386 glTexParameteri(target
, GL_TEXTURE_WRAP_S
, GL_CLAMP_TO_EDGE
);
387 glTexParameteri(target
, GL_TEXTURE_WRAP_T
, GL_CLAMP_TO_EDGE
);
388 // Border texels should not be used with CLAMP_TO_EDGE
389 // We set a sane default anyway.
390 glTexParameterfv(target
, GL_TEXTURE_BORDER_COLOR
, border
);
395 * \brief skips whitespace and comments
396 * \param f file to read from
398 static void ppm_skip(FILE *f
) {
406 } while (c
!= EOF
&& (isspace(c
) || comment
));
411 #define MAXDIM (16 * 1024)
414 * \brief creates a texture from a PPM file
415 * \param target texture taget, usually GL_TEXTURE_2D
416 * \param fmt internal texture format, 0 for default
417 * \param filter filter used for scaling, e.g. GL_LINEAR
418 * \param f file to read PPM from
419 * \param width [out] width of texture
420 * \param height [out] height of texture
421 * \param maxval [out] maxval value from PPM file
422 * \return 0 on error, 1 otherwise
425 int glCreatePPMTex(GLenum target
, GLenum fmt
, GLint filter
,
426 FILE *f
, int *width
, int *height
, int *maxval
) {
427 unsigned w
, h
, m
, val
, bpp
;
431 if (fgetc(f
) != 'P' || fgetc(f
) != '6')
434 if (fscanf(f
, "%u", &w
) != 1)
437 if (fscanf(f
, "%u", &h
) != 1)
440 if (fscanf(f
, "%u", &m
) != 1)
445 if (w
> MAXDIM
|| h
> MAXDIM
)
447 bpp
= (m
> 255) ? 6 : 3;
448 data
= malloc(w
* h
* bpp
);
449 if (fread(data
, w
* bpp
, h
, f
) != h
)
452 fmt
= (m
> 255) ? hqtexfmt
: 3;
453 if (fmt
== GL_FLOAT_RGB32_NV
&& target
!= GL_TEXTURE_RECTANGLE
)
456 type
= m
> 255 ? GL_UNSIGNED_SHORT
: GL_UNSIGNED_BYTE
;
457 glCreateClearTex(target
, fmt
, GL_RGB
, type
, filter
, w
, h
, 0);
458 glUploadTex(target
, GL_RGB
, type
,
459 data
, w
* bpp
, 0, 0, w
, h
, 0);
461 if (width
) *width
= w
;
462 if (height
) *height
= h
;
463 if (maxval
) *maxval
= m
;
468 * \brief return the number of bytes per pixel for the given format
469 * \param format OpenGL format
470 * \param type OpenGL type
471 * \return bytes per pixel
474 * Does not handle all possible variants, just those used by MPlayer
476 int glFmt2bpp(GLenum format
, GLenum type
) {
477 int component_size
= 0;
479 case GL_UNSIGNED_BYTE_3_3_2
:
480 case GL_UNSIGNED_BYTE_2_3_3_REV
:
482 case GL_UNSIGNED_SHORT_5_5_5_1
:
483 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
484 case GL_UNSIGNED_SHORT_5_6_5
:
485 case GL_UNSIGNED_SHORT_5_6_5_REV
:
487 case GL_UNSIGNED_BYTE
:
490 case GL_UNSIGNED_SHORT
:
497 return component_size
;
502 return 3 * component_size
;
505 return 4 * component_size
;
511 * \brief upload a texture, handling things like stride and slices
512 * \param target texture target, usually GL_TEXTURE_2D
513 * \param format OpenGL format of data
514 * \param type OpenGL type of data
515 * \param dataptr data to upload
516 * \param stride data stride
517 * \param x x offset in texture
518 * \param y y offset in texture
519 * \param w width of the texture part to upload
520 * \param h height of the texture part to upload
521 * \param slice height of an upload slice, 0 for all at once
524 void glUploadTex(GLenum target
, GLenum format
, GLenum type
,
525 const void *dataptr
, int stride
,
526 int x
, int y
, int w
, int h
, int slice
) {
527 const uint8_t *data
= dataptr
;
529 if (w
<= 0 || h
<= 0) return;
533 data
+= (h
- 1) * stride
;
536 // this is not always correct, but should work for MPlayer
537 glAdjustAlignment(stride
);
538 glPixelStorei(GL_UNPACK_ROW_LENGTH
, stride
/ glFmt2bpp(format
, type
));
539 for (; y
+ slice
<= y_max
; y
+= slice
) {
540 glTexSubImage2D(target
, 0, x
, y
, w
, slice
, format
, type
, data
);
541 data
+= stride
* slice
;
544 glTexSubImage2D(target
, 0, x
, y
, w
, y_max
- y
, format
, type
, data
);
547 static void fillUVcoeff(GLfloat
*ucoef
, GLfloat
*vcoef
,
548 float uvcos
, float uvsin
) {
550 ucoef
[0] = 0 * uvcos
+ 1.403 * uvsin
;
551 vcoef
[0] = 0 * uvsin
+ 1.403 * uvcos
;
552 ucoef
[1] = -0.344 * uvcos
+ -0.714 * uvsin
;
553 vcoef
[1] = -0.344 * uvsin
+ -0.714 * uvcos
;
554 ucoef
[2] = 1.770 * uvcos
+ 0 * uvsin
;
555 vcoef
[2] = 1.770 * uvsin
+ 0 * uvcos
;
558 // Coefficients (probably) must be in [0, 1] range, whereas they originally
559 // are in [-2, 2] range, so here comes the trick:
560 // First put them in the [-0.5, 0.5] range, then add 0.5.
561 // This can be undone with the HALF_BIAS and SCALE_BY_FOUR arguments
562 // for CombinerInput and CombinerOutput (or the respective ATI variants)
563 for (i
= 0; i
< 4; i
++) {
564 ucoef
[i
] = ucoef
[i
] * 0.25 + 0.5;
565 vcoef
[i
] = vcoef
[i
] * 0.25 + 0.5;
570 * \brief Setup register combiners for YUV to RGB conversion.
571 * \param uvcos used for saturation and hue adjustment
572 * \param uvsin used for saturation and hue adjustment
574 static void glSetupYUVCombiners(float uvcos
, float uvsin
) {
578 if (!CombinerInput
|| !CombinerOutput
||
579 !CombinerParameterfv
|| !CombinerParameteri
) {
580 mp_msg(MSGT_VO
, MSGL_FATAL
, "[gl] Combiner functions missing!\n");
583 glGetIntegerv(GL_MAX_GENERAL_COMBINERS_NV
, &i
);
585 mp_msg(MSGT_VO
, MSGL_ERR
,
586 "[gl] 2 general combiners needed for YUV combiner support (found %i)\n", i
);
587 glGetIntegerv(GL_MAX_TEXTURE_UNITS
, &i
);
589 mp_msg(MSGT_VO
, MSGL_ERR
,
590 "[gl] 3 texture units needed for YUV combiner support (found %i)\n", i
);
591 fillUVcoeff(ucoef
, vcoef
, uvcos
, uvsin
);
592 CombinerParameterfv(GL_CONSTANT_COLOR0_NV
, ucoef
);
593 CombinerParameterfv(GL_CONSTANT_COLOR1_NV
, vcoef
);
595 // UV first, like this green component cannot overflow
596 CombinerInput(GL_COMBINER0_NV
, GL_RGB
, GL_VARIABLE_A_NV
,
597 GL_TEXTURE1
, GL_HALF_BIAS_NORMAL_NV
, GL_RGB
);
598 CombinerInput(GL_COMBINER0_NV
, GL_RGB
, GL_VARIABLE_B_NV
,
599 GL_CONSTANT_COLOR0_NV
, GL_HALF_BIAS_NORMAL_NV
, GL_RGB
);
600 CombinerInput(GL_COMBINER0_NV
, GL_RGB
, GL_VARIABLE_C_NV
,
601 GL_TEXTURE2
, GL_HALF_BIAS_NORMAL_NV
, GL_RGB
);
602 CombinerInput(GL_COMBINER0_NV
, GL_RGB
, GL_VARIABLE_D_NV
,
603 GL_CONSTANT_COLOR1_NV
, GL_HALF_BIAS_NORMAL_NV
, GL_RGB
);
604 CombinerOutput(GL_COMBINER0_NV
, GL_RGB
, GL_DISCARD_NV
, GL_DISCARD_NV
,
605 GL_SPARE0_NV
, GL_SCALE_BY_FOUR_NV
, GL_NONE
, GL_FALSE
,
609 CombinerInput(GL_COMBINER1_NV
, GL_RGB
, GL_VARIABLE_A_NV
, GL_SPARE0_NV
,
610 GL_SIGNED_IDENTITY_NV
, GL_RGB
);
611 CombinerInput(GL_COMBINER1_NV
, GL_RGB
, GL_VARIABLE_B_NV
, GL_ZERO
,
612 GL_UNSIGNED_INVERT_NV
, GL_RGB
);
613 CombinerInput(GL_COMBINER1_NV
, GL_RGB
, GL_VARIABLE_C_NV
,
614 GL_TEXTURE0
, GL_SIGNED_IDENTITY_NV
, GL_RGB
);
615 CombinerInput(GL_COMBINER1_NV
, GL_RGB
, GL_VARIABLE_D_NV
, GL_ZERO
,
616 GL_UNSIGNED_INVERT_NV
, GL_RGB
);
617 CombinerOutput(GL_COMBINER1_NV
, GL_RGB
, GL_DISCARD_NV
, GL_DISCARD_NV
,
618 GL_SPARE0_NV
, GL_NONE
, GL_NONE
, GL_FALSE
,
621 // leave final combiner stage in default mode
622 CombinerParameteri(GL_NUM_GENERAL_COMBINERS_NV
, 2);
626 * \brief Setup ATI version of register combiners for YUV to RGB conversion.
627 * \param uvcos used for saturation and hue adjustment
628 * \param uvsin used for saturation and hue adjustment
630 * ATI called this fragment shader, but the name is confusing in the
631 * light of a very different OpenGL 2.0 extension with the same name
633 static void glSetupYUVCombinersATI(float uvcos
, float uvsin
) {
637 if (!BeginFragmentShader
|| !EndFragmentShader
||
638 !SetFragmentShaderConstant
|| !SampleMap
||
639 !ColorFragmentOp2
|| !ColorFragmentOp3
) {
640 mp_msg(MSGT_VO
, MSGL_FATAL
, "[gl] Combiner (ATI) functions missing!\n");
643 glGetIntegerv(GL_NUM_FRAGMENT_REGISTERS_ATI
, &i
);
645 mp_msg(MSGT_VO
, MSGL_ERR
,
646 "[gl] 3 registers needed for YUV combiner (ATI) support (found %i)\n", i
);
647 glGetIntegerv (GL_MAX_TEXTURE_UNITS
, &i
);
649 mp_msg(MSGT_VO
, MSGL_ERR
,
650 "[gl] 3 texture units needed for YUV combiner (ATI) support (found %i)\n", i
);
651 fillUVcoeff(ucoef
, vcoef
, uvcos
, uvsin
);
652 BeginFragmentShader();
653 SetFragmentShaderConstant(GL_CON_0_ATI
, ucoef
);
654 SetFragmentShaderConstant(GL_CON_1_ATI
, vcoef
);
655 SampleMap(GL_REG_0_ATI
, GL_TEXTURE0
, GL_SWIZZLE_STR_ATI
);
656 SampleMap(GL_REG_1_ATI
, GL_TEXTURE1
, GL_SWIZZLE_STR_ATI
);
657 SampleMap(GL_REG_2_ATI
, GL_TEXTURE2
, GL_SWIZZLE_STR_ATI
);
658 // UV first, like this green component cannot overflow
659 ColorFragmentOp2(GL_MUL_ATI
, GL_REG_1_ATI
, GL_NONE
, GL_NONE
,
660 GL_REG_1_ATI
, GL_NONE
, GL_BIAS_BIT_ATI
,
661 GL_CON_0_ATI
, GL_NONE
, GL_BIAS_BIT_ATI
);
662 ColorFragmentOp3(GL_MAD_ATI
, GL_REG_2_ATI
, GL_NONE
, GL_4X_BIT_ATI
,
663 GL_REG_2_ATI
, GL_NONE
, GL_BIAS_BIT_ATI
,
664 GL_CON_1_ATI
, GL_NONE
, GL_BIAS_BIT_ATI
,
665 GL_REG_1_ATI
, GL_NONE
, GL_NONE
);
666 ColorFragmentOp2(GL_ADD_ATI
, GL_REG_0_ATI
, GL_NONE
, GL_NONE
,
667 GL_REG_0_ATI
, GL_NONE
, GL_NONE
,
668 GL_REG_2_ATI
, GL_NONE
, GL_NONE
);
673 * \brief helper function for gen_spline_lookup_tex
674 * \param x subpixel-position ((0,1) range) to calculate weights for
675 * \param dst where to store transformed weights, must provide space for 4 GLfloats
677 * calculates the weights and stores them after appropriate transformation
678 * for the scaler fragment program.
680 static void store_weights(float x
, GLfloat
*dst
) {
681 float w0
= (((-1 * x
+ 3) * x
- 3) * x
+ 1) / 6;
682 float w1
= ((( 3 * x
- 6) * x
+ 0) * x
+ 4) / 6;
683 float w2
= (((-3 * x
+ 3) * x
+ 3) * x
+ 1) / 6;
684 float w3
= ((( 1 * x
+ 0) * x
+ 0) * x
+ 0) / 6;
685 *dst
++ = 1 + x
- w1
/ (w0
+ w1
);
686 *dst
++ = 1 - x
+ w3
/ (w2
+ w3
);
691 //! to avoid artefacts this should be rather large
692 #define LOOKUP_BSPLINE_RES (2 * 1024)
694 * \brief creates the 1D lookup texture needed for fast higher-order filtering
695 * \param unit texture unit to attach texture to
697 static void gen_spline_lookup_tex(GLenum unit
) {
698 GLfloat
*tex
= calloc(4 * LOOKUP_BSPLINE_RES
, sizeof(*tex
));
701 for (i
= 0; i
< LOOKUP_BSPLINE_RES
; i
++) {
702 float x
= (float)(i
+ 0.5) / LOOKUP_BSPLINE_RES
;
703 store_weights(x
, tp
);
706 store_weights(0, tex
);
707 store_weights(1, &tex
[4 * (LOOKUP_BSPLINE_RES
- 1)]);
709 glTexImage1D(GL_TEXTURE_1D
, 0, GL_RGBA16
, LOOKUP_BSPLINE_RES
, 0, GL_RGBA
, GL_FLOAT
, tex
);
710 glTexParameterf(GL_TEXTURE_1D
, GL_TEXTURE_PRIORITY
, 1.0);
711 glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
712 glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
713 glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_WRAP_S
, GL_REPEAT
);
714 ActiveTexture(GL_TEXTURE0
);
718 static const char *bilin_filt_template
=
719 "TEX yuv.%c, fragment.texcoord[%c], texture[%c], %s;";
721 #define BICUB_FILT_MAIN(textype) \
722 /* first y-interpolation */ \
723 "ADD coord, fragment.texcoord[%c].xyxy, cdelta.xyxw;" \
724 "ADD coord2, fragment.texcoord[%c].xyxy, cdelta.zyzw;" \
725 "TEX a.r, coord.xyxy, texture[%c], "textype";" \
726 "TEX a.g, coord.zwzw, texture[%c], "textype";" \
727 /* second y-interpolation */ \
728 "TEX b.r, coord2.xyxy, texture[%c], "textype";" \
729 "TEX b.g, coord2.zwzw, texture[%c], "textype";" \
730 "LRP a.b, parmy.b, a.rrrr, a.gggg;" \
731 "LRP a.a, parmy.b, b.rrrr, b.gggg;" \
732 /* x-interpolation */ \
733 "LRP yuv.%c, parmx.b, a.bbbb, a.aaaa;"
735 static const char *bicub_filt_template_2D
=
736 "MAD coord.xy, fragment.texcoord[%c], {%f, %f}, {0.5, 0.5};"
737 "TEX parmx, coord.x, texture[%c], 1D;"
738 "MUL cdelta.xz, parmx.rrgg, {-%f, 0, %f, 0};"
739 "TEX parmy, coord.y, texture[%c], 1D;"
740 "MUL cdelta.yw, parmy.rrgg, {0, -%f, 0, %f};"
741 BICUB_FILT_MAIN("2D");
743 static const char *bicub_filt_template_RECT
=
744 "ADD coord, fragment.texcoord[%c], {0.5, 0.5};"
745 "TEX parmx, coord.x, texture[%c], 1D;"
746 "MUL cdelta.xz, parmx.rrgg, {-1, 0, 1, 0};"
747 "TEX parmy, coord.y, texture[%c], 1D;"
748 "MUL cdelta.yw, parmy.rrgg, {0, -1, 0, 1};"
749 BICUB_FILT_MAIN("RECT");
751 #define CALCWEIGHTS(t, s) \
752 "MAD "t", {-0.5, 0.1666, 0.3333, -0.3333}, "s", {1, 0, -0.5, 0.5};" \
753 "MAD "t", "t", "s", {0, 0, -0.5, 0.5};" \
754 "MAD "t", "t", "s", {-0.6666, 0, 0.8333, 0.1666};" \
757 "MAD "t".xy, "t".xyxy, a.xyxy, {1, 1, 0, 0};" \
758 "ADD "t".x, "t".xxxx, "s";" \
759 "SUB "t".y, "t".yyyy, "s";"
761 static const char *bicub_notex_filt_template_2D
=
762 "MAD coord.xy, fragment.texcoord[%c], {%f, %f}, {0.5, 0.5};"
763 "FRC coord.xy, coord.xyxy;"
764 CALCWEIGHTS("parmx", "coord.xxxx")
765 "MUL cdelta.xz, parmx.rrgg, {-%f, 0, %f, 0};"
766 CALCWEIGHTS("parmy", "coord.yyyy")
767 "MUL cdelta.yw, parmy.rrgg, {0, -%f, 0, %f};"
768 BICUB_FILT_MAIN("2D");
770 static const char *bicub_notex_filt_template_RECT
=
771 "ADD coord, fragment.texcoord[%c], {0.5, 0.5};"
772 "FRC coord.xy, coord.xyxy;"
773 CALCWEIGHTS("parmx", "coord.xxxx")
774 "MUL cdelta.xz, parmx.rrgg, {-1, 0, 1, 0};"
775 CALCWEIGHTS("parmy", "coord.yyyy")
776 "MUL cdelta.yw, parmy.rrgg, {0, -1, 0, 1};"
777 BICUB_FILT_MAIN("RECT");
779 #define BICUB_X_FILT_MAIN(textype) \
780 "ADD coord.xy, fragment.texcoord[%c].xyxy, cdelta.xyxy;" \
781 "ADD coord2.xy, fragment.texcoord[%c].xyxy, cdelta.zyzy;" \
782 "TEX a.r, coord, texture[%c], "textype";" \
783 "TEX b.r, coord2, texture[%c], "textype";" \
784 /* x-interpolation */ \
785 "LRP yuv.%c, parmx.b, a.rrrr, b.rrrr;"
787 static const char *bicub_x_filt_template_2D
=
788 "MAD coord.x, fragment.texcoord[%c], {%f}, {0.5};"
789 "TEX parmx, coord, texture[%c], 1D;"
790 "MUL cdelta.xyz, parmx.rrgg, {-%f, 0, %f};"
791 BICUB_X_FILT_MAIN("2D");
793 static const char *bicub_x_filt_template_RECT
=
794 "ADD coord.x, fragment.texcoord[%c], {0.5};"
795 "TEX parmx, coord, texture[%c], 1D;"
796 "MUL cdelta.xyz, parmx.rrgg, {-1, 0, 1};"
797 BICUB_X_FILT_MAIN("RECT");
799 static const char *unsharp_filt_template
=
800 "PARAM dcoord%c = {%f, %f, %f, %f};"
801 "ADD coord, fragment.texcoord[%c].xyxy, dcoord%c;"
802 "SUB coord2, fragment.texcoord[%c].xyxy, dcoord%c;"
803 "TEX a.r, fragment.texcoord[%c], texture[%c], %s;"
804 "TEX b.r, coord.xyxy, texture[%c], %s;"
805 "TEX b.g, coord.zwzw, texture[%c], %s;"
807 "TEX b.b, coord2.xyxy, texture[%c], %s;"
808 "TEX b.g, coord2.zwzw, texture[%c], %s;"
809 "DP3 b, b, {0.25, 0.25, 0.25};"
811 "MAD yuv.%c, b.r, {%f}, a.r;";
813 static const char *unsharp_filt_template2
=
814 "PARAM dcoord%c = {%f, %f, %f, %f};"
815 "PARAM dcoord2%c = {%f, 0, 0, %f};"
816 "ADD coord, fragment.texcoord[%c].xyxy, dcoord%c;"
817 "SUB coord2, fragment.texcoord[%c].xyxy, dcoord%c;"
818 "TEX a.r, fragment.texcoord[%c], texture[%c], %s;"
819 "TEX b.r, coord.xyxy, texture[%c], %s;"
820 "TEX b.g, coord.zwzw, texture[%c], %s;"
822 "TEX b.b, coord2.xyxy, texture[%c], %s;"
823 "TEX b.g, coord2.zwzw, texture[%c], %s;"
826 "ADD coord, fragment.texcoord[%c].xyxy, dcoord2%c;"
827 "SUB coord2, fragment.texcoord[%c].xyxy, dcoord2%c;"
828 "TEX b.r, coord.xyxy, texture[%c], %s;"
829 "TEX b.g, coord.zwzw, texture[%c], %s;"
831 "TEX b.b, coord2.xyxy, texture[%c], %s;"
832 "TEX b.g, coord2.zwzw, texture[%c], %s;"
833 "DP4 b.r, b, {-0.1171875, -0.1171875, -0.1171875, -0.09765625};"
834 "MAD b.r, a.r, {0.859375}, b.r;"
835 "MAD yuv.%c, b.r, {%f}, a.r;";
837 static const char *yuv_prog_template
=
838 "PARAM ycoef = {%.4f, %.4f, %.4f};"
839 "PARAM ucoef = {%.4f, %.4f, %.4f};"
840 "PARAM vcoef = {%.4f, %.4f, %.4f};"
841 "PARAM offsets = {%.4f, %.4f, %.4f};"
843 "MAD res.rgb, yuv.rrrr, ycoef, offsets;"
844 "MAD res.rgb, yuv.gggg, ucoef, res;"
845 "MAD result.color.rgb, yuv.bbbb, vcoef, res;"
848 static const char *yuv_pow_prog_template
=
849 "PARAM ycoef = {%.4f, %.4f, %.4f};"
850 "PARAM ucoef = {%.4f, %.4f, %.4f};"
851 "PARAM vcoef = {%.4f, %.4f, %.4f};"
852 "PARAM offsets = {%.4f, %.4f, %.4f};"
853 "PARAM gamma = {%.4f, %.4f, %.4f};"
855 "MAD res.rgb, yuv.rrrr, ycoef, offsets;"
856 "MAD res.rgb, yuv.gggg, ucoef, res;"
857 "MAD_SAT res.rgb, yuv.bbbb, vcoef, res;"
858 "POW result.color.r, res.r, gamma.r;"
859 "POW result.color.g, res.g, gamma.g;"
860 "POW result.color.b, res.b, gamma.b;"
863 static const char *yuv_lookup_prog_template
=
864 "PARAM ycoef = {%.4f, %.4f, %.4f, 0};"
865 "PARAM ucoef = {%.4f, %.4f, %.4f, 0};"
866 "PARAM vcoef = {%.4f, %.4f, %.4f, 0};"
867 "PARAM offsets = {%.4f, %.4f, %.4f, 0.125};"
869 "MAD res, yuv.rrrr, ycoef, offsets;"
870 "MAD res.rgb, yuv.gggg, ucoef, res;"
871 "MAD res.rgb, yuv.bbbb, vcoef, res;"
872 "TEX result.color.r, res.raaa, texture[%c], 2D;"
873 "ADD res.a, res.a, 0.25;"
874 "TEX result.color.g, res.gaaa, texture[%c], 2D;"
875 "ADD res.a, res.a, 0.25;"
876 "TEX result.color.b, res.baaa, texture[%c], 2D;"
879 static const char *yuv_lookup3d_prog_template
=
880 "TEX result.color, yuv, texture[%c], 3D;"
884 * \brief creates and initializes helper textures needed for scaling texture read
885 * \param scaler scaler type to create texture for
886 * \param texu contains next free texture unit number
887 * \param texs texture unit ids for the scaler are stored in this array
889 static void create_scaler_textures(int scaler
, int *texu
, char *texs
) {
891 case YUV_SCALER_BILIN
:
892 case YUV_SCALER_BICUB_NOTEX
:
893 case YUV_SCALER_UNSHARP
:
894 case YUV_SCALER_UNSHARP2
:
896 case YUV_SCALER_BICUB
:
897 case YUV_SCALER_BICUB_X
:
899 gen_spline_lookup_tex(GL_TEXTURE0
+ texs
[0]);
903 mp_msg(MSGT_VO
, MSGL_ERR
, "[gl] unknown scaler type %i\n", scaler
);
907 static void gen_gamma_map(unsigned char *map
, int size
, float gamma
);
917 static void get_yuv2rgb_coeffs(gl_conversion_params_t
*params
, float yuv2rgb
[3][4]) {
918 float uvcos
= params
->saturation
* cos(params
->hue
);
919 float uvsin
= params
->saturation
* sin(params
->hue
);
921 float uv_coeffs
[3][2] = {
926 for (i
= 0; i
< 3; i
++) {
927 yuv2rgb
[i
][COL_C
] = params
->brightness
;
928 yuv2rgb
[i
][COL_Y
] = 1.164 * params
->contrast
;
929 yuv2rgb
[i
][COL_C
] += (-16 / 255.0) * yuv2rgb
[i
][COL_Y
];
930 yuv2rgb
[i
][COL_U
] = uv_coeffs
[i
][0] * uvcos
+ uv_coeffs
[i
][1] * uvsin
;
931 yuv2rgb
[i
][COL_C
] += (-128 / 255.0) * yuv2rgb
[i
][COL_U
];
932 yuv2rgb
[i
][COL_V
] = uv_coeffs
[i
][0] * uvsin
+ uv_coeffs
[i
][1] * uvcos
;
933 yuv2rgb
[i
][COL_C
] += (-128 / 255.0) * yuv2rgb
[i
][COL_V
];
934 // this "centers" contrast control so that e.g. a contrast of 0
935 // leads to a grey image, not a black one
936 yuv2rgb
[i
][COL_C
] += 0.5 - params
->contrast
/ 2.0;
940 //! size of gamma map use to avoid slow exp function in gen_yuv2rgb_map
941 #define GMAP_SIZE (1024)
943 * \brief generate a 3D YUV -> RGB map
944 * \param params struct containing parameters like brightness, gamma, ...
945 * \param map where to store map. Must provide space for (size + 2)^3 elements
946 * \param size size of the map, excluding border
948 static void gen_yuv2rgb_map(gl_conversion_params_t
*params
, unsigned char *map
, int size
) {
950 float step
= 1.0 / size
;
953 unsigned char gmaps
[3][GMAP_SIZE
];
954 gen_gamma_map(gmaps
[0], GMAP_SIZE
, params
->rgamma
);
955 gen_gamma_map(gmaps
[1], GMAP_SIZE
, params
->ggamma
);
956 gen_gamma_map(gmaps
[2], GMAP_SIZE
, params
->bgamma
);
957 get_yuv2rgb_coeffs(params
, yuv2rgb
);
958 for (i
= 0; i
< 3; i
++)
959 for (j
= 0; j
< 4; j
++)
960 yuv2rgb
[i
][j
] *= GMAP_SIZE
- 1;
962 for (i
= -1; i
<= size
; i
++) {
964 for (j
= -1; j
<= size
; j
++) {
966 for (k
= -1; k
<= size
; k
++) {
967 for (l
= 0; l
< 3; l
++) {
968 float rgb
= yuv2rgb
[l
][COL_Y
] * y
+ yuv2rgb
[l
][COL_U
] * u
+ yuv2rgb
[l
][COL_V
] * v
+ yuv2rgb
[l
][COL_C
];
969 *map
++ = gmaps
[l
][av_clip(rgb
, 0, GMAP_SIZE
- 1)];
971 y
+= (k
== -1 || k
== size
- 1) ? step
/ 2 : step
;
973 u
+= (j
== -1 || j
== size
- 1) ? step
/ 2 : step
;
975 v
+= (i
== -1 || i
== size
- 1) ? step
/ 2 : step
;
979 //! resolution of texture for gamma lookup table
980 #define LOOKUP_RES 512
981 //! resolution for 3D yuv->rgb conversion lookup table
982 #define LOOKUP_3DRES 32
984 * \brief creates and initializes helper textures needed for yuv conversion
985 * \param params struct containing parameters like brightness, gamma, ...
986 * \param texu contains next free texture unit number
987 * \param texs texture unit ids for the conversion are stored in this array
989 static void create_conv_textures(gl_conversion_params_t
*params
, int *texu
, char *texs
) {
990 unsigned char *lookup_data
= NULL
;
991 int conv
= YUV_CONVERSION(params
->type
);
993 case YUV_CONVERSION_FRAGMENT
:
994 case YUV_CONVERSION_FRAGMENT_POW
:
996 case YUV_CONVERSION_FRAGMENT_LOOKUP
:
998 ActiveTexture(GL_TEXTURE0
+ texs
[0]);
999 lookup_data
= malloc(4 * LOOKUP_RES
);
1000 gen_gamma_map(lookup_data
, LOOKUP_RES
, params
->rgamma
);
1001 gen_gamma_map(&lookup_data
[LOOKUP_RES
], LOOKUP_RES
, params
->ggamma
);
1002 gen_gamma_map(&lookup_data
[2 * LOOKUP_RES
], LOOKUP_RES
, params
->bgamma
);
1003 glCreateClearTex(GL_TEXTURE_2D
, GL_LUMINANCE8
, GL_LUMINANCE
, GL_UNSIGNED_BYTE
, GL_LINEAR
,
1005 glUploadTex(GL_TEXTURE_2D
, GL_LUMINANCE
, GL_UNSIGNED_BYTE
, lookup_data
,
1006 LOOKUP_RES
, 0, 0, LOOKUP_RES
, 4, 0);
1007 ActiveTexture(GL_TEXTURE0
);
1010 case YUV_CONVERSION_FRAGMENT_LOOKUP3D
:
1012 int sz
= LOOKUP_3DRES
+ 2; // texture size including borders
1014 mp_msg(MSGT_VO
, MSGL_ERR
, "[gl] Missing 3D texture function!\n");
1017 texs
[0] = (*texu
)++;
1018 ActiveTexture(GL_TEXTURE0
+ texs
[0]);
1019 lookup_data
= malloc(3 * sz
* sz
* sz
);
1020 gen_yuv2rgb_map(params
, lookup_data
, LOOKUP_3DRES
);
1021 glAdjustAlignment(sz
);
1022 glPixelStorei(GL_UNPACK_ROW_LENGTH
, 0);
1023 TexImage3D(GL_TEXTURE_3D
, 0, 3, sz
, sz
, sz
, 1,
1024 GL_RGB
, GL_UNSIGNED_BYTE
, lookup_data
);
1025 glTexParameterf(GL_TEXTURE_3D
, GL_TEXTURE_PRIORITY
, 1.0);
1026 glTexParameteri(GL_TEXTURE_3D
, GL_TEXTURE_MIN_FILTER
, GL_LINEAR
);
1027 glTexParameteri(GL_TEXTURE_3D
, GL_TEXTURE_MAG_FILTER
, GL_LINEAR
);
1028 glTexParameteri(GL_TEXTURE_3D
, GL_TEXTURE_WRAP_S
, GL_CLAMP
);
1029 glTexParameteri(GL_TEXTURE_3D
, GL_TEXTURE_WRAP_T
, GL_CLAMP
);
1030 glTexParameteri(GL_TEXTURE_3D
, GL_TEXTURE_WRAP_R
, GL_CLAMP
);
1031 ActiveTexture(GL_TEXTURE0
);
1036 mp_msg(MSGT_VO
, MSGL_ERR
, "[gl] unknown conversion type %i\n", conv
);
1043 * \brief adds a scaling texture read at the current fragment program position
1044 * \param scaler type of scaler to insert
1045 * \param prog_pos current position in fragment program
1046 * \param remain how many bytes remain in the buffer given by prog_pos
1047 * \param texs array containing the texture unit identifiers for this scaler
1048 * \param in_tex texture unit the scaler should read from
1049 * \param out_comp component of the yuv variable the scaler stores the result in
1050 * \param rect if rectangular (pixel) adressing should be used for in_tex
1051 * \param texw width of the in_tex texture
1052 * \param texh height of the in_tex texture
1053 * \param strength strength of filter effect if the scaler does some kind of filtering
1055 static void add_scaler(int scaler
, char **prog_pos
, int *remain
, char *texs
,
1056 char in_tex
, char out_comp
, int rect
, int texw
, int texh
,
1058 const char *ttype
= rect
? "RECT" : "2D";
1059 const float ptw
= rect
? 1.0 : 1.0 / texw
;
1060 const float pth
= rect
? 1.0 : 1.0 / texh
;
1062 case YUV_SCALER_BILIN
:
1063 snprintf(*prog_pos
, *remain
, bilin_filt_template
, out_comp
, in_tex
,
1066 case YUV_SCALER_BICUB
:
1068 snprintf(*prog_pos
, *remain
, bicub_filt_template_RECT
,
1069 in_tex
, texs
[0], texs
[0],
1070 in_tex
, in_tex
, in_tex
, in_tex
, in_tex
, in_tex
, out_comp
);
1072 snprintf(*prog_pos
, *remain
, bicub_filt_template_2D
,
1073 in_tex
, (float)texw
, (float)texh
,
1074 texs
[0], ptw
, ptw
, texs
[0], pth
, pth
,
1075 in_tex
, in_tex
, in_tex
, in_tex
, in_tex
, in_tex
, out_comp
);
1077 case YUV_SCALER_BICUB_X
:
1079 snprintf(*prog_pos
, *remain
, bicub_x_filt_template_RECT
,
1081 in_tex
, in_tex
, in_tex
, in_tex
, out_comp
);
1083 snprintf(*prog_pos
, *remain
, bicub_x_filt_template_2D
,
1084 in_tex
, (float)texw
,
1086 in_tex
, in_tex
, in_tex
, in_tex
, out_comp
);
1088 case YUV_SCALER_BICUB_NOTEX
:
1090 snprintf(*prog_pos
, *remain
, bicub_notex_filt_template_RECT
,
1092 in_tex
, in_tex
, in_tex
, in_tex
, in_tex
, in_tex
, out_comp
);
1094 snprintf(*prog_pos
, *remain
, bicub_notex_filt_template_2D
,
1095 in_tex
, (float)texw
, (float)texh
, ptw
, ptw
, pth
, pth
,
1096 in_tex
, in_tex
, in_tex
, in_tex
, in_tex
, in_tex
, out_comp
);
1098 case YUV_SCALER_UNSHARP
:
1099 snprintf(*prog_pos
, *remain
, unsharp_filt_template
,
1100 out_comp
, 0.5 * ptw
, 0.5 * pth
, 0.5 * ptw
, -0.5 * pth
,
1101 in_tex
, out_comp
, in_tex
, out_comp
, in_tex
,
1102 in_tex
, ttype
, in_tex
, ttype
, in_tex
, ttype
, in_tex
, ttype
,
1103 in_tex
, ttype
, out_comp
, strength
);
1105 case YUV_SCALER_UNSHARP2
:
1106 snprintf(*prog_pos
, *remain
, unsharp_filt_template2
,
1107 out_comp
, 1.2 * ptw
, 1.2 * pth
, 1.2 * ptw
, -1.2 * pth
,
1108 out_comp
, 1.5 * ptw
, 1.5 * pth
,
1109 in_tex
, out_comp
, in_tex
, out_comp
, in_tex
,
1110 in_tex
, ttype
, in_tex
, ttype
, in_tex
, ttype
, in_tex
, ttype
,
1111 in_tex
, ttype
, in_tex
, out_comp
, in_tex
, out_comp
,
1112 in_tex
, ttype
, in_tex
, ttype
, in_tex
, ttype
,
1113 in_tex
, ttype
, out_comp
, strength
);
1116 *remain
-= strlen(*prog_pos
);
1117 *prog_pos
+= strlen(*prog_pos
);
1120 static const struct {
1125 {"instructions", 0x88A0, 0x88A1},
1126 {"native instructions", 0x88A2, 0x88A3},
1127 {"temporaries", 0x88A4, 0x88A5},
1128 {"native temporaries", 0x88A6, 0x88A7},
1129 {"parameters", 0x88A8, 0x88A9},
1130 {"native parameters", 0x88AA, 0x88AB},
1131 {"attribs", 0x88AC, 0x88AD},
1132 {"native attribs", 0x88AE, 0x88AF},
1133 {"ALU instructions", 0x8805, 0x880B},
1134 {"TEX instructions", 0x8806, 0x880C},
1135 {"TEX indirections", 0x8807, 0x880D},
1136 {"native ALU instructions", 0x8808, 0x880E},
1137 {"native TEX instructions", 0x8809, 0x880F},
1138 {"native TEX indirections", 0x880A, 0x8810},
1143 * \brief load the specified GPU Program
1144 * \param target program target to load into, only GL_FRAGMENT_PROGRAM is tested
1145 * \param prog program string
1146 * \return 1 on success, 0 otherwise
1148 int loadGPUProgram(GLenum target
, char *prog
) {
1150 GLint cur
= 0, max
= 0, err
= 0;
1151 if (!ProgramString
) {
1152 mp_msg(MSGT_VO
, MSGL_ERR
, "[gl] Missing GPU program function\n");
1155 ProgramString(target
, GL_PROGRAM_FORMAT_ASCII
, strlen(prog
), prog
);
1156 glGetIntegerv(GL_PROGRAM_ERROR_POSITION
, &err
);
1158 mp_msg(MSGT_VO
, MSGL_ERR
,
1159 "[gl] Error compiling fragment program, make sure your card supports\n"
1160 "[gl] GL_ARB_fragment_program (use glxinfo to check).\n"
1161 "[gl] Error message:\n %s at %.10s\n",
1162 glGetString(GL_PROGRAM_ERROR_STRING
), &prog
[err
]);
1165 if (!GetProgramiv
|| !mp_msg_test(MSGT_VO
, MSGL_V
))
1167 mp_msg(MSGT_VO
, MSGL_V
, "[gl] Program statistics:\n");
1168 for (i
= 0; progstats
[i
].name
; i
++) {
1169 GetProgramiv(target
, progstats
[i
].cur
, &cur
);
1170 GetProgramiv(target
, progstats
[i
].max
, &max
);
1171 mp_msg(MSGT_VO
, MSGL_V
, "[gl] %s: %i/%i\n", progstats
[i
].name
, cur
, max
);
1176 #define MAX_PROGSZ (1024*1024)
1179 * \brief setup a fragment program that will do YUV->RGB conversion
1180 * \param parms struct containing parameters like conversion and scaler type,
1183 static void glSetupYUVFragprog(gl_conversion_params_t
*params
) {
1184 int type
= params
->type
;
1185 int texw
= params
->texw
;
1186 int texh
= params
->texh
;
1187 int rect
= params
->target
== GL_TEXTURE_RECTANGLE
;
1188 static const char prog_hdr
[] =
1190 "OPTION ARB_precision_hint_fastest;"
1191 // all scaler variables must go here so they aren't defined
1192 // multiple times when the same scaler is used more than once
1193 "TEMP coord, coord2, cdelta, parmx, parmy, a, b, yuv;";
1195 char *yuv_prog
, *prog_pos
;
1197 char lum_scale_texs
[1];
1198 char chrom_scale_texs
[1];
1201 // this is the conversion matrix, with y, u, v factors
1202 // for red, green, blue and the constant offsets
1203 float yuv2rgb
[3][4];
1204 create_conv_textures(params
, &cur_texu
, conv_texs
);
1205 create_scaler_textures(YUV_LUM_SCALER(type
), &cur_texu
, lum_scale_texs
);
1206 if (YUV_CHROM_SCALER(type
) == YUV_LUM_SCALER(type
))
1207 memcpy(chrom_scale_texs
, lum_scale_texs
, sizeof(chrom_scale_texs
));
1209 create_scaler_textures(YUV_CHROM_SCALER(type
), &cur_texu
, chrom_scale_texs
);
1210 glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS
, &i
);
1212 mp_msg(MSGT_VO
, MSGL_ERR
,
1213 "[gl] %i texture units needed for this type of YUV fragment support (found %i)\n",
1215 if (!ProgramString
) {
1216 mp_msg(MSGT_VO
, MSGL_FATAL
, "[gl] ProgramString function missing!\n");
1219 yuv_prog
= malloc(MAX_PROGSZ
);
1220 strcpy(yuv_prog
, prog_hdr
);
1221 prog_pos
= yuv_prog
+ sizeof(prog_hdr
) - 1;
1222 prog_remain
= MAX_PROGSZ
- sizeof(prog_hdr
);
1223 add_scaler(YUV_LUM_SCALER(type
), &prog_pos
, &prog_remain
, lum_scale_texs
,
1224 '0', 'r', rect
, texw
, texh
, params
->filter_strength
);
1225 add_scaler(YUV_CHROM_SCALER(type
), &prog_pos
, &prog_remain
, chrom_scale_texs
,
1226 '1', 'g', rect
, texw
/ 2, texh
/ 2, params
->filter_strength
);
1227 add_scaler(YUV_CHROM_SCALER(type
), &prog_pos
, &prog_remain
, chrom_scale_texs
,
1228 '2', 'b', rect
, texw
/ 2, texh
/ 2, params
->filter_strength
);
1229 get_yuv2rgb_coeffs(params
, yuv2rgb
);
1230 switch (YUV_CONVERSION(type
)) {
1231 case YUV_CONVERSION_FRAGMENT
:
1232 snprintf(prog_pos
, prog_remain
, yuv_prog_template
,
1233 yuv2rgb
[ROW_R
][COL_Y
], yuv2rgb
[ROW_G
][COL_Y
], yuv2rgb
[ROW_B
][COL_Y
],
1234 yuv2rgb
[ROW_R
][COL_U
], yuv2rgb
[ROW_G
][COL_U
], yuv2rgb
[ROW_B
][COL_U
],
1235 yuv2rgb
[ROW_R
][COL_V
], yuv2rgb
[ROW_G
][COL_V
], yuv2rgb
[ROW_B
][COL_V
],
1236 yuv2rgb
[ROW_R
][COL_C
], yuv2rgb
[ROW_G
][COL_C
], yuv2rgb
[ROW_B
][COL_C
]);
1238 case YUV_CONVERSION_FRAGMENT_POW
:
1239 snprintf(prog_pos
, prog_remain
, yuv_pow_prog_template
,
1240 yuv2rgb
[ROW_R
][COL_Y
], yuv2rgb
[ROW_G
][COL_Y
], yuv2rgb
[ROW_B
][COL_Y
],
1241 yuv2rgb
[ROW_R
][COL_U
], yuv2rgb
[ROW_G
][COL_U
], yuv2rgb
[ROW_B
][COL_U
],
1242 yuv2rgb
[ROW_R
][COL_V
], yuv2rgb
[ROW_G
][COL_V
], yuv2rgb
[ROW_B
][COL_V
],
1243 yuv2rgb
[ROW_R
][COL_C
], yuv2rgb
[ROW_G
][COL_C
], yuv2rgb
[ROW_B
][COL_C
],
1244 (float)1.0 / params
->rgamma
, (float)1.0 / params
->bgamma
, (float)1.0 / params
->bgamma
);
1246 case YUV_CONVERSION_FRAGMENT_LOOKUP
:
1247 snprintf(prog_pos
, prog_remain
, yuv_lookup_prog_template
,
1248 yuv2rgb
[ROW_R
][COL_Y
], yuv2rgb
[ROW_G
][COL_Y
], yuv2rgb
[ROW_B
][COL_Y
],
1249 yuv2rgb
[ROW_R
][COL_U
], yuv2rgb
[ROW_G
][COL_U
], yuv2rgb
[ROW_B
][COL_U
],
1250 yuv2rgb
[ROW_R
][COL_V
], yuv2rgb
[ROW_G
][COL_V
], yuv2rgb
[ROW_B
][COL_V
],
1251 yuv2rgb
[ROW_R
][COL_C
], yuv2rgb
[ROW_G
][COL_C
], yuv2rgb
[ROW_B
][COL_C
],
1252 conv_texs
[0], conv_texs
[0], conv_texs
[0]);
1254 case YUV_CONVERSION_FRAGMENT_LOOKUP3D
:
1255 snprintf(prog_pos
, prog_remain
, yuv_lookup3d_prog_template
, conv_texs
[0]);
1258 mp_msg(MSGT_VO
, MSGL_ERR
, "[gl] unknown conversion type %i\n", YUV_CONVERSION(type
));
1261 mp_msg(MSGT_VO
, MSGL_V
, "[gl] generated fragment program:\n%s\n", yuv_prog
);
1262 loadGPUProgram(GL_FRAGMENT_PROGRAM
, yuv_prog
);
1267 * \brief little helper function to create a lookup table for gamma
1268 * \param map buffer to create map into
1269 * \param size size of buffer
1270 * \param gamma gamma value
1272 static void gen_gamma_map(unsigned char *map
, int size
, float gamma
) {
1275 for (i
= 0; i
< size
; i
++)
1276 map
[i
] = 255 * i
/ (size
- 1);
1279 gamma
= 1.0 / gamma
;
1280 for (i
= 0; i
< size
; i
++) {
1281 float tmp
= (float)i
/ (size
- 1.0);
1282 tmp
= pow(tmp
, gamma
);
1283 if (tmp
> 1.0) tmp
= 1.0;
1284 if (tmp
< 0.0) tmp
= 0.0;
1290 * \brief setup YUV->RGB conversion
1291 * \param parms struct containing parameters like conversion and scaler type,
1293 * \ingroup glconversion
1295 void glSetupYUVConversion(gl_conversion_params_t
*params
) {
1296 float uvcos
= params
->saturation
* cos(params
->hue
);
1297 float uvsin
= params
->saturation
* sin(params
->hue
);
1298 switch (YUV_CONVERSION(params
->type
)) {
1299 case YUV_CONVERSION_COMBINERS
:
1300 glSetupYUVCombiners(uvcos
, uvsin
);
1302 case YUV_CONVERSION_COMBINERS_ATI
:
1303 glSetupYUVCombinersATI(uvcos
, uvsin
);
1305 case YUV_CONVERSION_FRAGMENT_LOOKUP
:
1306 case YUV_CONVERSION_FRAGMENT_LOOKUP3D
:
1307 case YUV_CONVERSION_FRAGMENT
:
1308 case YUV_CONVERSION_FRAGMENT_POW
:
1309 glSetupYUVFragprog(params
);
1312 mp_msg(MSGT_VO
, MSGL_ERR
, "[gl] unknown conversion type %i\n", YUV_CONVERSION(params
->type
));
1317 * \brief enable the specified YUV conversion
1318 * \param target texture target for Y, U and V textures (e.g. GL_TEXTURE_2D)
1319 * \param type type of YUV conversion
1320 * \ingroup glconversion
1322 void glEnableYUVConversion(GLenum target
, int type
) {
1323 if (type
<= 0) return;
1324 switch (YUV_CONVERSION(type
)) {
1325 case YUV_CONVERSION_COMBINERS
:
1326 ActiveTexture(GL_TEXTURE1
);
1328 ActiveTexture(GL_TEXTURE2
);
1330 ActiveTexture(GL_TEXTURE0
);
1331 glEnable(GL_REGISTER_COMBINERS_NV
);
1333 case YUV_CONVERSION_COMBINERS_ATI
:
1334 ActiveTexture(GL_TEXTURE1
);
1336 ActiveTexture(GL_TEXTURE2
);
1338 ActiveTexture(GL_TEXTURE0
);
1339 glEnable(GL_FRAGMENT_SHADER_ATI
);
1341 case YUV_CONVERSION_FRAGMENT_LOOKUP3D
:
1342 case YUV_CONVERSION_FRAGMENT_LOOKUP
:
1343 case YUV_CONVERSION_FRAGMENT_POW
:
1344 case YUV_CONVERSION_FRAGMENT
:
1345 glEnable(GL_FRAGMENT_PROGRAM
);
1351 * \brief disable the specified YUV conversion
1352 * \param target texture target for Y, U and V textures (e.g. GL_TEXTURE_2D)
1353 * \param type type of YUV conversion
1354 * \ingroup glconversion
1356 void glDisableYUVConversion(GLenum target
, int type
) {
1357 if (type
<= 0) return;
1358 switch (YUV_CONVERSION(type
)) {
1359 case YUV_CONVERSION_COMBINERS
:
1360 ActiveTexture(GL_TEXTURE1
);
1362 ActiveTexture(GL_TEXTURE2
);
1364 ActiveTexture(GL_TEXTURE0
);
1365 glDisable(GL_REGISTER_COMBINERS_NV
);
1367 case YUV_CONVERSION_COMBINERS_ATI
:
1368 ActiveTexture(GL_TEXTURE1
);
1370 ActiveTexture(GL_TEXTURE2
);
1372 ActiveTexture(GL_TEXTURE0
);
1373 glDisable(GL_FRAGMENT_SHADER_ATI
);
1375 case YUV_CONVERSION_FRAGMENT_LOOKUP3D
:
1376 case YUV_CONVERSION_FRAGMENT_LOOKUP
:
1377 case YUV_CONVERSION_FRAGMENT_POW
:
1378 case YUV_CONVERSION_FRAGMENT
:
1379 glDisable(GL_FRAGMENT_PROGRAM
);
1385 * \brief draw a texture part at given 2D coordinates
1386 * \param x screen top coordinate
1387 * \param y screen left coordinate
1388 * \param w screen width coordinate
1389 * \param h screen height coordinate
1390 * \param tx texture top coordinate in pixels
1391 * \param ty texture left coordinate in pixels
1392 * \param tw texture part width in pixels
1393 * \param th texture part height in pixels
1394 * \param sx width of texture in pixels
1395 * \param sy height of texture in pixels
1396 * \param rect_tex whether this texture uses texture_rectangle extension
1397 * \param is_yv12 if set, also draw the textures from units 1 and 2
1398 * \param flip flip the texture upside down
1399 * \ingroup gltexture
1401 void glDrawTex(GLfloat x
, GLfloat y
, GLfloat w
, GLfloat h
,
1402 GLfloat tx
, GLfloat ty
, GLfloat tw
, GLfloat th
,
1403 int sx
, int sy
, int rect_tex
, int is_yv12
, int flip
) {
1404 GLfloat tx2
= tx
/ 2, ty2
= ty
/ 2, tw2
= tw
/ 2, th2
= th
/ 2;
1406 tx
/= sx
; ty
/= sy
; tw
/= sx
; th
/= sy
;
1407 tx2
= tx
, ty2
= ty
, tw2
= tw
, th2
= th
;
1414 glTexCoord2f(tx
, ty
);
1416 MultiTexCoord2f(GL_TEXTURE1
, tx2
, ty2
);
1417 MultiTexCoord2f(GL_TEXTURE2
, tx2
, ty2
);
1420 glTexCoord2f(tx
, ty
+ th
);
1422 MultiTexCoord2f(GL_TEXTURE1
, tx2
, ty2
+ th2
);
1423 MultiTexCoord2f(GL_TEXTURE2
, tx2
, ty2
+ th2
);
1425 glVertex2f(x
, y
+ h
);
1426 glTexCoord2f(tx
+ tw
, ty
+ th
);
1428 MultiTexCoord2f(GL_TEXTURE1
, tx2
+ tw2
, ty2
+ th2
);
1429 MultiTexCoord2f(GL_TEXTURE2
, tx2
+ tw2
, ty2
+ th2
);
1431 glVertex2f(x
+ w
, y
+ h
);
1432 glTexCoord2f(tx
+ tw
, ty
);
1434 MultiTexCoord2f(GL_TEXTURE1
, tx2
+ tw2
, ty2
);
1435 MultiTexCoord2f(GL_TEXTURE2
, tx2
+ tw2
, ty2
);
1437 glVertex2f(x
+ w
, y
);
1442 #include "w32_common.h"
1444 * \brief little helper since wglGetProcAddress definition does not fit our
1446 * \param procName name of function to look up
1447 * \return function pointer returned by wglGetProcAddress
1449 static void *w32gpa(const GLubyte
*procName
) {
1451 void *res
= wglGetProcAddress(procName
);
1452 if (res
) return res
;
1453 oglmod
= GetModuleHandle("opengl32.dll");
1454 return GetProcAddress(oglmod
, procName
);
1457 int setGlWindow(int *vinfo
, HGLRC
*context
, HWND win
)
1460 HDC windc
= GetDC(win
);
1461 HGLRC new_context
= 0;
1462 int keep_context
= 0;
1463 int res
= SET_WINDOW_FAILED
;
1465 // should only be needed when keeping context, but not doing glFinish
1466 // can cause flickering even when we do not keep it.
1469 new_vinfo
= GetPixelFormat(windc
);
1470 if (*context
&& *vinfo
&& new_vinfo
&& *vinfo
== new_vinfo
) {
1471 // we can keep the wglContext
1472 new_context
= *context
;
1476 new_context
= wglCreateContext(windc
);
1478 mp_msg(MSGT_VO
, MSGL_FATAL
, "[gl] Could not create GL context!\n");
1484 if (!wglMakeCurrent(windc
, new_context
)) {
1485 mp_msg(MSGT_VO
, MSGL_FATAL
, "[gl] Could not set GL context!\n");
1486 if (!keep_context
) {
1487 wglDeleteContext(new_context
);
1493 vo_w32_window
= win
;
1496 GetClientRect(win
, &rect
);
1497 vo_dwidth
= rect
.right
;
1498 vo_dheight
= rect
.bottom
;
1500 if (!keep_context
) {
1502 wglDeleteContext(*context
);
1503 *context
= new_context
;
1505 getFunctions(w32gpa
, NULL
);
1507 // and inform that reinit is neccessary
1508 res
= SET_WINDOW_REINIT
;
1510 res
= SET_WINDOW_OK
;
1513 ReleaseDC(win
, windc
);
1517 void releaseGlContext(int *vinfo
, HGLRC
*context
) {
1520 wglMakeCurrent(0, 0);
1521 wglDeleteContext(*context
);
1526 void swapGlBuffers(void) {
1527 HDC vo_hdc
= GetDC(vo_w32_window
);
1528 SwapBuffers(vo_hdc
);
1529 ReleaseDC(vo_w32_window
, vo_hdc
);
1535 #include "x11_common.h"
1537 * \brief find address of a linked function
1538 * \param s name of function to find
1539 * \return address of function or NULL if not found
1541 static void *getdladdr(const char *s
) {
1544 void *handle
= dlopen(NULL
, RTLD_LAZY
);
1547 ret
= dlsym(handle
, s
);
1554 * \brief Returns the XVisualInfo associated with Window win.
1555 * \param win Window whose XVisualInfo is returne.
1556 * \return XVisualInfo of the window. Caller must use XFree to free it.
1558 static XVisualInfo
*getWindowVisualInfo(Window win
) {
1559 XWindowAttributes xw_attr
;
1560 XVisualInfo vinfo_template
;
1562 XGetWindowAttributes(mDisplay
, win
, &xw_attr
);
1563 vinfo_template
.visualid
= XVisualIDFromVisual(xw_attr
.visual
);
1564 return XGetVisualInfo(mDisplay
, VisualIDMask
, &vinfo_template
, &tmp
);
1567 static void appendstr(char **dst
, const char *str
)
1573 newsize
= strlen(*dst
) + 1 + strlen(str
) + 1;
1574 newstr
= realloc(*dst
, newsize
);
1583 * \brief Changes the window in which video is displayed.
1584 * If possible only transfers the context to the new window, otherwise
1585 * creates a new one, which must be initialized by the caller.
1586 * \param vinfo Currently used visual.
1587 * \param context Currently used context.
1588 * \param win window that should be used for drawing.
1589 * \return one of SET_WINDOW_FAILED, SET_WINDOW_OK or SET_WINDOW_REINIT.
1590 * In case of SET_WINDOW_REINIT the context could not be transfered
1591 * and the caller must initialize it correctly.
1592 * \ingroup glcontext
1594 int setGlWindow(XVisualInfo
**vinfo
, GLXContext
*context
, Window win
)
1596 XVisualInfo
*new_vinfo
;
1597 GLXContext new_context
= NULL
;
1598 int keep_context
= 0;
1600 // should only be needed when keeping context, but not doing glFinish
1601 // can cause flickering even when we do not keep it.
1604 new_vinfo
= getWindowVisualInfo(win
);
1605 if (*context
&& *vinfo
&& new_vinfo
&&
1606 (*vinfo
)->visualid
== new_vinfo
->visualid
) {
1607 // we can keep the GLXContext
1608 new_context
= *context
;
1614 new_context
= glXCreateContext(mDisplay
, new_vinfo
, NULL
, True
);
1616 mp_msg(MSGT_VO
, MSGL_FATAL
, "[gl] Could not create GLX context!\n");
1618 return SET_WINDOW_FAILED
;
1623 if (!glXMakeCurrent(mDisplay
, vo_window
, new_context
)) {
1624 mp_msg(MSGT_VO
, MSGL_FATAL
, "[gl] Could not set GLX context!\n");
1625 if (!keep_context
) {
1626 glXDestroyContext(mDisplay
, new_context
);
1629 return SET_WINDOW_FAILED
;
1634 vo_x11_update_geometry();
1635 if (!keep_context
) {
1636 void *(*getProcAddress
)(const GLubyte
*);
1637 const char *(*glXExtStr
)(Display
*, int);
1638 char *glxstr
= strdup("");
1640 glXDestroyContext(mDisplay
, *context
);
1641 *context
= new_context
;
1645 getProcAddress
= getdladdr("glXGetProcAddress");
1646 if (!getProcAddress
)
1647 getProcAddress
= getdladdr("glXGetProcAddressARB");
1648 if (!getProcAddress
)
1649 getProcAddress
= (void *)getdladdr
;
1650 glXExtStr
= getdladdr("glXQueryExtensionsString");
1652 appendstr(&glxstr
, glXExtStr(mDisplay
, DefaultScreen(mDisplay
)));
1653 glXExtStr
= getdladdr("glXGetClientString");
1655 appendstr(&glxstr
, glXExtStr(mDisplay
, GLX_EXTENSIONS
));
1656 glXExtStr
= getdladdr("glXGetServerString");
1658 appendstr(&glxstr
, glXExtStr(mDisplay
, GLX_EXTENSIONS
));
1660 getFunctions(getProcAddress
, glxstr
);
1663 // and inform that reinit is neccessary
1664 return SET_WINDOW_REINIT
;
1666 return SET_WINDOW_OK
;
1670 * \brief free the VisualInfo and GLXContext of an OpenGL context.
1671 * \ingroup glcontext
1673 void releaseGlContext(XVisualInfo
**vinfo
, GLXContext
*context
) {
1680 glXMakeCurrent(mDisplay
, None
, NULL
);
1681 glXDestroyContext(mDisplay
, *context
);
1686 void swapGlBuffers(void) {
1687 glXSwapBuffers(mDisplay
, vo_window
);