[Mplayer-cvslog] CVS: main/libvo vo_gl2.c,1.25,1.26 vo_x11.c,1.122,1.123 x11_common.c,1.106,1.107 x11_common.h,1.27,1.28

[Arpi of Ize]

Update of /cvsroot/mplayer/main/libvo
In directory mail:/var/tmp.root/cvs-serv30418

Modified Files:
	vo_gl2.c vo_x11.c x11_common.c x11_common.h 
Log Message:
here is a somewhat generic equalizer implementation for the X11 vo drivers
using the window's colormap (DirectColor).
this method is using the video card's hardware gamma ramp so it involves
no performance penalties at all.
patch by lucho <lucho at haemimont.bg>


Index: vo_gl2.c
===================================================================
RCS file: /cvsroot/mplayer/main/libvo/vo_gl2.c,v
retrieving revision 1.25
retrieving revision 1.26
diff -u -r1.25 -r1.26
--- vo_gl2.c	27 Oct 2002 03:16:21 -0000	1.25
+++ vo_gl2.c	29 Oct 2002 20:27:47 -0000	1.26
@@ -598,6 +598,50 @@
 static void draw_alpha_null(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride){
 }
 
+static int choose_glx_visual(Display *dpy, int scr, XVisualInfo *res_vi)
+{
+	XVisualInfo template, *vi_list;
+	int vi_num, i, best_i, best_weight;
+	
+	template.screen = scr;
+	vi_list = XGetVisualInfo(dpy, VisualScreenMask, &template, &vi_num);
+	if (!vi_list) return -1;
+	best_weight = 1000000;
+	for (i = 0; i < vi_num; i++) {
+		int val, res, w = 0;
+		/* of course, the visual must support OpenGL rendering... */
+		res = glXGetConfig(dpy, vi_list + i, GLX_USE_GL, &val);
+		if (res || val == False) continue;
+		/* also it must be doublebuffered ... */
+		res = glXGetConfig(dpy, vi_list + i, GLX_DOUBLEBUFFER, &val);
+		if (res || val == False) continue;
+		/* furthermore it must be RGBA (not color indexed) ... */
+		res = glXGetConfig(dpy, vi_list + i, GLX_RGBA, &val);
+		if (res || val == False) continue;
+		/* prefer less depth buffer size, */
+		res = glXGetConfig(dpy, vi_list + i, GLX_DEPTH_SIZE, &val);
+		if (res) continue;
+		w += val*2;
+		/* stencil buffer size */
+		res = glXGetConfig(dpy, vi_list + i, GLX_STENCIL_SIZE, &val);
+		if (res) continue;
+		w += val*2;
+		/* and colorbuffer alpha size */
+		res = glXGetConfig(dpy, vi_list + i, GLX_ALPHA_SIZE, &val);
+		if (res) continue;
+		w += val;
+		/* and finally, prefer DirectColor-ed visuals to allow color corrections */
+		if (vi_list[i].class != DirectColor) w += 100;
+		if (w < best_weight) {
+			best_weight = w;
+			best_i = i;
+		}
+	}
+	if (best_weight < 1000000) *res_vi = vi_list[best_i];
+	XFree(vi_list);
+	return (best_weight < 1000000) ? 0 : -1;
+}
+
 /* connect to server, create and map window,
  * allocate colors and (shared) memory
  */
@@ -609,7 +653,7 @@
 	char *hello = (title == NULL) ? "OpenGL rulez" : title;
 //	char *name = ":0.0";
 	XSizeHints hint;
-	XVisualInfo *vinfo;
+	XVisualInfo *vinfo, vinfo_buf;
 	XEvent xev;
 
 //	XGCValues xgcv;
@@ -655,7 +699,7 @@
 //	XGetWindowAttributes(mDisplay, DefaultRootWindow(mDisplay), &attribs);
 
 //	XMatchVisualInfo(mDisplay, screen, depth, TrueColor, &vinfo);
-  vinfo=glXChooseVisual( mDisplay,mScreen,wsGLXAttrib );
+  vinfo = choose_glx_visual(mDisplay,mScreen,&vinfo_buf) < 0 ? NULL : &vinfo_buf;
   if (vinfo == NULL)
   {
     printf("[gl2] no GLX support present\n");
@@ -664,7 +708,7 @@
 
 	xswa.background_pixel = 0;
 	xswa.border_pixel     = 1;
-	xswa.colormap         = XCreateColormap(mDisplay, mRootWin, vinfo->visual, AllocNone);
+	xswa.colormap         = vo_x11_create_colormap(vinfo);
 	xswamask = CWBackPixel | CWBorderPixel | CWColormap;
 
   if ( vo_window == None ) 
@@ -1115,6 +1159,26 @@
   switch (request) {
   case VOCTRL_QUERY_FORMAT:
     return query_format(*((uint32_t*)data));
+  case VOCTRL_SET_EQUALIZER:
+    {
+      va_list ap;
+      int value;
+    
+      va_start(ap, data);
+      value = va_arg(ap, int);
+      va_end(ap);
+      return vo_x11_set_equalizer(data, value);
+	}
+  case VOCTRL_GET_EQUALIZER:
+    {
+      va_list ap;
+      int *value;
+    
+      va_start(ap, data);
+      value = va_arg(ap, int *);
+      va_end(ap);
+      return vo_x11_get_equalizer(data, value);
+    }
   }
   return VO_NOTIMPL;
 }

Index: vo_x11.c
===================================================================
RCS file: /cvsroot/mplayer/main/libvo/vo_x11.c,v
retrieving revision 1.122
retrieving revision 1.123
diff -u -r1.122 -r1.123
--- vo_x11.c	16 Oct 2002 22:44:09 -0000	1.122
+++ vo_x11.c	29 Oct 2002 20:27:47 -0000	1.123
@@ -260,7 +260,8 @@
    Visual *visual;
    depth = vo_find_depth_from_visuals(mDisplay, mScreen, &visual);
  }
- XMatchVisualInfo( mDisplay,mScreen,depth,TrueColor,&vinfo );
+ if ( !XMatchVisualInfo( mDisplay,mScreen,depth,DirectColor,&vinfo ))
+   XMatchVisualInfo( mDisplay,mScreen,depth,TrueColor,&vinfo );
 
  /* set image size (which is indeed neither the input nor output size), 
     if zoom is on it will be changed during draw_slice anyway so we dont dupplicate the aspect code here 
@@ -292,7 +293,7 @@
     bg=WhitePixel( mDisplay,mScreen );
     fg=BlackPixel( mDisplay,mScreen );
 
-    theCmap=XCreateColormap( mDisplay,mRootWin,vinfo.visual,AllocNone );
+    theCmap=vo_x11_create_colormap(&vinfo);
 
     xswa.background_pixel=0;
     xswa.border_pixel=0;
@@ -633,6 +634,24 @@
     return VO_TRUE;
   case VOCTRL_GET_IMAGE:
     return get_image(data);
+  case VOCTRL_SET_EQUALIZER:
+    {
+      va_list ap;
+      int value;
+      va_start(ap, data);
+      value = va_arg(ap, int);
+      va_end(ap);
+      return vo_x11_set_equalizer(data, value);
+	}
+  case VOCTRL_GET_EQUALIZER:
+    {
+      va_list ap;
+      int *value;
+      va_start(ap, data);
+      value = va_arg(ap, int *);
+      va_end(ap);
+      return vo_x11_get_equalizer(data, value);
+    }
   case VOCTRL_FULLSCREEN:
     vo_x11_fullscreen();
     return VO_TRUE;

Index: x11_common.c
===================================================================
RCS file: /cvsroot/mplayer/main/libvo/x11_common.c,v
retrieving revision 1.106
retrieving revision 1.107
diff -u -r1.106 -r1.107
--- x11_common.c	16 Oct 2002 22:53:18 -0000	1.106
+++ x11_common.c	29 Oct 2002 20:27:47 -0000	1.107
@@ -1,6 +1,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <math.h>
 #include <inttypes.h>
 
 #include "config.h"
@@ -968,4 +969,136 @@
   }
   return bestvisual_depth;
 }
+
+
+static Colormap cmap = None;
+static XColor cols[256];
+static int cm_size, red_mask, green_mask, blue_mask;
+
+
+Colormap vo_x11_create_colormap(XVisualInfo *vinfo)
+{
+	unsigned k, r, g, b, ru, gu, bu, m, rv, gv, bv, rvu, gvu, bvu;
+
+	if (vinfo->class != DirectColor)
+	 return XCreateColormap(mDisplay, mRootWin, vinfo->visual, AllocNone);
+
+	/* can this function get called twice or more? */
+	if (cmap) return cmap;
+	cm_size = vinfo->colormap_size;
+	red_mask = vinfo->red_mask;
+	green_mask = vinfo->green_mask;
+	blue_mask = vinfo->blue_mask;
+	ru = (red_mask&(red_mask-1))^red_mask;
+	gu = (green_mask&(green_mask-1))^green_mask;
+	bu = (blue_mask&(blue_mask-1))^blue_mask;
+	rvu = 65536ull*ru/(red_mask + ru);
+	gvu = 65536ull*gu/(green_mask + gu);
+	bvu = 65536ull*bu/(blue_mask + bu);
+	r = g = b = 0;
+	rv = gv = bv = 0;
+	m = DoRed|DoGreen|DoBlue;
+	for (k = 0; k < cm_size; k++) {
+		int t;
+		cols[k].pixel = r|g|b;
+		cols[k].red = rv;
+		cols[k].green = gv;
+		cols[k].blue = bv;
+		cols[k].flags = m;
+		t = (r + ru) & red_mask; if (t < r) m &= ~DoRed; r = t;
+		t = (g + gu) & green_mask; if (t < g) m &= ~DoGreen; g = t;
+		t = (b + bu) & blue_mask; if (t < b) m &= ~DoBlue; b = t;
+		rv += rvu;
+		gv += gvu;
+		bv += bvu;
+	}
+	cmap = XCreateColormap(mDisplay, mRootWin, vinfo->visual, AllocAll);
+	XStoreColors(mDisplay, cmap, cols, cm_size);
+	return cmap;
+}
+
+/*
+ * Via colormaps/gamma ramps we can do gamma, brightness, contrast,
+ * hue and red/green/blue intensity, but we cannot do saturation.
+ * Currently only gamma, brightness and contrast are implemented.
+ * Is there sufficient interest for hue and/or red/green/blue intensity?
+ */
+/* these values have range [-100,100] and are initially 0 */
+static int vo_gamma = 0;
+static int vo_brightness = 0;
+static int vo_contrast = 0;
+
+
+uint32_t vo_x11_set_equalizer(char *name, int value)
+{
+	float gamma, brightness, contrast;
+	float rf, gf, bf;
+	int k;
+
+	/*
+	 * IMPLEMENTME: consider using XF86VidModeSetGammaRamp in the case
+	 * of TrueColor-ed window but be careful:
+	 * unlike the colormaps, which are private for the X client
+	 * who created them and thus automatically destroyed on client
+	 * disconnect, this gamma ramp is a system-wide (X-server-wide)
+	 * setting and _must_ be restored before the process exit.
+	 * Unforunately when the process crashes (or get killed
+	 * for some reason) it is impossible to restore the setting,
+	 * and such behaviour could be rather annoying for the users.
+	 */
+	if (cmap == None) return VO_NOTAVAIL;
+
+	if (!strcasecmp(name, "brightness")) vo_brightness = value;
+	else if (!strcasecmp(name, "contrast")) vo_contrast = value;
+	else if (!strcasecmp(name, "gamma")) vo_gamma = value;
+	else return VO_NOTIMPL;
+	
+	brightness = 0.01*vo_brightness;
+	contrast = tan(0.0095*(vo_contrast+100)*M_PI/4);
+	gamma = pow(2, -0.02*vo_gamma);
+
+	rf = (float)((red_mask & (red_mask - 1)) ^ red_mask)/red_mask;
+	gf = (float)((green_mask & (green_mask - 1)) ^ green_mask)/green_mask;
+	bf = (float)((blue_mask & (blue_mask - 1)) ^ blue_mask)/blue_mask;
+
+	/* now recalculate the colormap using the newly set value */
+	for (k = 0; k < cm_size; k++) {
+		float s;
+
+		s = pow(rf*k, gamma);
+		s = (s - 0.5)*contrast + 0.5;
+		s += brightness;
+		if (s < 0) s = 0;
+		if (s > 1) s = 1;
+		cols[k].red = (unsigned short)(s * 65535);
+
+		s = pow(gf*k, gamma);
+		s = (s - 0.5)*contrast + 0.5;
+		s += brightness;
+		if (s < 0) s = 0;
+		if (s > 1) s = 1;
+		cols[k].green = (unsigned short)(s * 65535);
+
+		s = pow(bf*k, gamma);
+		s = (s - 0.5)*contrast + 0.5;
+		s += brightness;
+		if (s < 0) s = 0;
+		if (s > 1) s = 1;
+		cols[k].blue = (unsigned short)(s * 65535);
+	}
+		
+	XStoreColors(mDisplay, cmap, cols, cm_size);
+	XFlush(mDisplay);
+	return VO_TRUE;
+}
+
+uint32_t vo_x11_get_equalizer(char *name, int *value)
+{
+	if (cmap == None) return VO_NOTAVAIL;
+	if (!strcasecmp(name, "brightness")) *value = vo_brightness;
+	else if (!strcasecmp(name, "contrast")) *value = vo_contrast;
+	else if (!strcasecmp(name, "gamma")) *value = vo_gamma;
+	else return VO_NOTIMPL;
+}
+
 

Index: x11_common.h
===================================================================
RCS file: /cvsroot/mplayer/main/libvo/x11_common.h,v
retrieving revision 1.27
retrieving revision 1.28
diff -u -r1.27 -r1.28
--- x11_common.h	3 Sep 2002 18:10:42 -0000	1.27
+++ x11_common.h	29 Oct 2002 20:27:47 -0000	1.28
@@ -36,6 +36,9 @@
 extern void vo_x11_selectinput_witherr(Display *display, Window w, long event_mask);
 extern void vo_x11_fullscreen( void );
 extern void vo_x11_uninit();
+extern Colormap vo_x11_create_colormap(XVisualInfo *vinfo);
+extern uint32_t vo_x11_set_equalizer(char *name, int value);
+extern uint32_t vo_x11_get_equalizer(char *name, int *value);
 
 #endif