major reindentation of x11 code try #2

note that this is plain ident output, i didnt tweak it by
hand like the last attempt.

if anyone is interested in the indent profile i used, just drop me a mail.

please contact me on irc on how to send me my share of cola,
but be aware that i will only accept swiss or german cola, as the japanese is
way to sweet :)


git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@12583 b3059339-0415-0410-9bf9-f77b7e298cf2

1 files changed, 748 insertions, 534 deletions

diff --git a/libvo/vo_xv.c b/libvo/vo_xv.c
index 8062385e9f..f461953d0a 100644
--- a/libvo/vo_xv.c
+++ b/libvo/vo_xv.c
@@ -40,23 +40,20 @@ Buffer allocation:
 #include "../Gui/interface.h"
 #endif
 
-static vo_info_t info =
-{
-        "X11/Xv",
-        "xv",
-        "Gerd Knorr <kraxel@goldbach.in-berlin.de> and others",
-        ""
+static vo_info_t info = {
+    "X11/Xv",
+    "xv",
+    "Gerd Knorr <kraxel@goldbach.in-berlin.de> and others",
+    ""
 };
 
 LIBVO_EXTERN(xv)
-
 #ifdef HAVE_SHM
 #include <sys/ipc.h>
 #include <sys/shm.h>
 #include <X11/extensions/XShm.h>
-
 /* since it doesn't seem to be defined on some platforms */
-int XShmGetEventBase(Display*);
+int XShmGetEventBase(Display *);
 
 static XShmSegmentInfo Shminfo[NUM_BUFFERS];
 static int Shmem_Flag;
@@ -68,15 +65,15 @@ static int Shmem_Flag;
 
 // FIXME: dynamically allocate this stuff
 static void allocate_xvimage(int);
-static unsigned int ver,rel,req,ev,err;
+static unsigned int ver, rel, req, ev, err;
 static unsigned int formats, adaptors, xv_port, xv_format;
-static XvAdaptorInfo        *ai = NULL;
-static XvImageFormatValues  *fo;
+static XvAdaptorInfo *ai = NULL;
+static XvImageFormatValues *fo;
 
-static int current_buf=0;
-static int current_ip_buf=0;
-static int num_buffers=1; // default
-static XvImage* xvimage[NUM_BUFFERS];
+static int current_buf = 0;
+static int current_ip_buf = 0;
+static int num_buffers = 1;     // default
+static XvImage *xvimage[NUM_BUFFERS];
 
 
 static uint32_t image_width;
@@ -86,34 +83,54 @@ static int flip_flag;
 
 static int int_pause;
 
-static Window                 mRoot;
-static uint32_t               drwX,drwY,drwBorderWidth,drwDepth;
-static uint32_t               dwidth,dheight;
+static Window mRoot;
+static uint32_t drwX, drwY, drwBorderWidth, drwDepth;
+static uint32_t dwidth, dheight;
 
-static void (*draw_alpha_fnc)(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride);
+static void (*draw_alpha_fnc) (int x0, int y0, int w, int h,
+                               unsigned char *src, unsigned char *srca,
+                               int stride);
 
-static void draw_alpha_yv12(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride){
-   x0+=image_width*(vo_panscan_x>>1)/(vo_dwidth+vo_panscan_x);
-   vo_draw_alpha_yv12(w,h,src,srca,stride,
-       xvimage[current_buf]->data+xvimage[current_buf]->offsets[0]+
-       xvimage[current_buf]->pitches[0]*y0+x0,xvimage[current_buf]->pitches[0]);
+static void draw_alpha_yv12(int x0, int y0, int w, int h,
+                            unsigned char *src, unsigned char *srca,
+                            int stride)
+{
+    x0 += image_width * (vo_panscan_x >> 1) / (vo_dwidth + vo_panscan_x);
+    vo_draw_alpha_yv12(w, h, src, srca, stride,
+                       xvimage[current_buf]->data +
+                       xvimage[current_buf]->offsets[0] +
+                       xvimage[current_buf]->pitches[0] * y0 + x0,
+                       xvimage[current_buf]->pitches[0]);
 }
 
-static void draw_alpha_yuy2(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride){
-   x0+=image_width*(vo_panscan_x>>1)/(vo_dwidth+vo_panscan_x);
-   vo_draw_alpha_yuy2(w,h,src,srca,stride,
-       xvimage[current_buf]->data+xvimage[current_buf]->offsets[0]+
-       xvimage[current_buf]->pitches[0]*y0+2*x0,xvimage[current_buf]->pitches[0]);
+static void draw_alpha_yuy2(int x0, int y0, int w, int h,
+                            unsigned char *src, unsigned char *srca,
+                            int stride)
+{
+    x0 += image_width * (vo_panscan_x >> 1) / (vo_dwidth + vo_panscan_x);
+    vo_draw_alpha_yuy2(w, h, src, srca, stride,
+                       xvimage[current_buf]->data +
+                       xvimage[current_buf]->offsets[0] +
+                       xvimage[current_buf]->pitches[0] * y0 + 2 * x0,
+                       xvimage[current_buf]->pitches[0]);
 }
 
-static void draw_alpha_uyvy(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride){
-   x0+=image_width*(vo_panscan_x>>1)/(vo_dwidth+vo_panscan_x);
-   vo_draw_alpha_yuy2(w,h,src,srca,stride,
-       xvimage[current_buf]->data+xvimage[current_buf]->offsets[0]+
-       xvimage[current_buf]->pitches[0]*y0+2*x0+1,xvimage[current_buf]->pitches[0]);
+static void draw_alpha_uyvy(int x0, int y0, int w, int h,
+                            unsigned char *src, unsigned char *srca,
+                            int stride)
+{
+    x0 += image_width * (vo_panscan_x >> 1) / (vo_dwidth + vo_panscan_x);
+    vo_draw_alpha_yuy2(w, h, src, srca, stride,
+                       xvimage[current_buf]->data +
+                       xvimage[current_buf]->offsets[0] +
+                       xvimage[current_buf]->pitches[0] * y0 + 2 * x0 + 1,
+                       xvimage[current_buf]->pitches[0]);
 }
 
-static void draw_alpha_null(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride){
+static void draw_alpha_null(int x0, int y0, int w, int h,
+                            unsigned char *src, unsigned char *srca,
+                            int stride)
+{
 }
 
 
@@ -123,451 +140,605 @@ static void deallocate_xvimage(int foo);
  * connect to server, create and map window,
  * allocate colors and (shared) memory
  */
-static uint32_t config(uint32_t width, uint32_t height, uint32_t d_width, uint32_t d_height, uint32_t flags, char *title, uint32_t format)
+static uint32_t config(uint32_t width, uint32_t height, uint32_t d_width,
+                       uint32_t d_height, uint32_t flags, char *title,
+                       uint32_t format)
 {
 // int screen;
- char *hello = (title == NULL) ? "Xv render" : title;
+    char *hello = (title == NULL) ? "Xv render" : title;
+
 // char *name = ":0.0";
- XSizeHints hint;
- XVisualInfo vinfo;
- XGCValues xgcv;
- XSetWindowAttributes xswa;
- XWindowAttributes attribs;
- unsigned long xswamask;
- int depth;
+    XSizeHints hint;
+    XVisualInfo vinfo;
+    XGCValues xgcv;
+    XSetWindowAttributes xswa;
+    XWindowAttributes attribs;
+    unsigned long xswamask;
+    int depth;
+
 #ifdef HAVE_XF86VM
- int vm=0;
- unsigned int modeline_width, modeline_height;
- static uint32_t vm_width;
- static uint32_t vm_height;
+    int vm = 0;
+    unsigned int modeline_width, modeline_height;
+    static uint32_t vm_width;
+    static uint32_t vm_height;
 #endif
 
- panscan_init();
+    panscan_init();
+
+    aspect_save_orig(width, height);
+    aspect_save_prescale(d_width, d_height);
 
- aspect_save_orig(width,height);
- aspect_save_prescale(d_width,d_height);
+    image_height = height;
+    image_width = width;
+    image_format = format;
 
- image_height = height;
- image_width = width;
- image_format=format;
- 
- vo_mouse_autohide=1;
+    vo_mouse_autohide = 1;
 
- int_pause=0;
+    int_pause = 0;
+
+    vo_dx = (vo_screenwidth - d_width) / 2;
+    vo_dy = (vo_screenheight - d_height) / 2;
+    geometry(&vo_dx, &vo_dy, &d_width, &d_height, vo_screenwidth,
+             vo_screenheight);
+    vo_dwidth = d_width;
+    vo_dheight = d_height;
 
- vo_dx=( vo_screenwidth - d_width ) / 2; vo_dy=( vo_screenheight - d_height ) / 2;
- geometry(&vo_dx, &vo_dy, &d_width, &d_height, vo_screenwidth, vo_screenheight);
- vo_dwidth=d_width; vo_dheight=d_height;
-     
 #ifdef HAVE_XF86VM
- if( flags&0x02 ) vm = 1;
+    if (flags & 0x02)
+        vm = 1;
 #endif
- flip_flag=flags&8;
- num_buffers=vo_doublebuffering?(vo_directrendering?NUM_BUFFERS:2):1;
-
-   /* check image formats */
-   {
-     unsigned int i;
-
-     xv_format=0;
-     for(i = 0; i < formats; i++){
-       mp_msg(MSGT_VO,MSGL_V,"Xvideo image format: 0x%x (%4.4s) %s\n", fo[i].id,(char*)&fo[i].id, (fo[i].format == XvPacked) ? "packed" : "planar");
-       if (fo[i].id == format) xv_format = fo[i].id;
-     }
-     if (!xv_format) return -1;
-   }
- aspect_save_screenres(vo_screenwidth,vo_screenheight);
+    flip_flag = flags & 8;
+    num_buffers =
+        vo_doublebuffering ? (vo_directrendering ? NUM_BUFFERS : 2) : 1;
+
+    /* check image formats */
+    {
+        unsigned int i;
+
+        xv_format = 0;
+        for (i = 0; i < formats; i++)
+        {
+            mp_msg(MSGT_VO, MSGL_V,
+                   "Xvideo image format: 0x%x (%4.4s) %s\n", fo[i].id,
+                   (char *) &fo[i].id,
+                   (fo[i].format == XvPacked) ? "packed" : "planar");
+            if (fo[i].id == format)
+                xv_format = fo[i].id;
+        }
+        if (!xv_format)
+            return -1;
+    }
+    aspect_save_screenres(vo_screenwidth, vo_screenheight);
 
 #ifdef HAVE_NEW_GUI
-  if(use_gui)
-    guiGetEvent( guiSetShVideo,0 ); // let the GUI to setup/resize our window
-  else
-#endif
-  {
-   hint.x = vo_dx;
-   hint.y = vo_dy;
-   aspect(&d_width,&d_height,A_NOZOOM);
-   hint.width = d_width;
-   hint.height = d_height;
-#ifdef HAVE_XF86VM
-    if ( vm )
-      {
-	if ((d_width==0) && (d_height==0))
-	  { vm_width=image_width; vm_height=image_height; }
-	else
-	  { vm_width=d_width; vm_height=d_height; }
-	vo_vm_switch(vm_width, vm_height,&modeline_width, &modeline_height);
-	hint.x=(vo_screenwidth-modeline_width)/2;
-	hint.y=(vo_screenheight-modeline_height)/2;
-	hint.width=modeline_width;
-	hint.height=modeline_height;
-	aspect_save_screenres(modeline_width,modeline_height);
-      }
+    if (use_gui)
+        guiGetEvent(guiSetShVideo, 0);  // let the GUI to setup/resize our window
     else
 #endif
-   if ( vo_fs )
     {
+        hint.x = vo_dx;
+        hint.y = vo_dy;
+        aspect(&d_width, &d_height, A_NOZOOM);
+        hint.width = d_width;
+        hint.height = d_height;
+#ifdef HAVE_XF86VM
+        if (vm)
+        {
+            if ((d_width == 0) && (d_height == 0))
+            {
+                vm_width = image_width;
+                vm_height = image_height;
+            } else
+            {
+                vm_width = d_width;
+                vm_height = d_height;
+            }
+            vo_vm_switch(vm_width, vm_height, &modeline_width,
+                         &modeline_height);
+            hint.x = (vo_screenwidth - modeline_width) / 2;
+            hint.y = (vo_screenheight - modeline_height) / 2;
+            hint.width = modeline_width;
+            hint.height = modeline_height;
+            aspect_save_screenres(modeline_width, modeline_height);
+        } else
+#endif
+        if (vo_fs)
+        {
 #ifdef X11_FULLSCREEN
-     /* this code replaces X11_FULLSCREEN hack in mplayer.c
-      * aspect() is available through aspect.h for all vos.
-      * besides zooming should only be done with -zoom,
-      * but I leave the old -fs behaviour so users don't get
-      * irritated for now (and send lots o' mails ;) ::atmos
-      */
-
-     aspect(&d_width,&d_height,A_ZOOM);
+            /* this code replaces X11_FULLSCREEN hack in mplayer.c
+             * aspect() is available through aspect.h for all vos.
+             * besides zooming should only be done with -zoom,
+             * but I leave the old -fs behaviour so users don't get
+             * irritated for now (and send lots o' mails ;) ::atmos
+             */
+
+            aspect(&d_width, &d_height, A_ZOOM);
 #endif
 
-    }
+        }
 //   dwidth=d_width; dheight=d_height; //XXX: what are the copy vars used for?
-   vo_dwidth=d_width; vo_dheight=d_height;
-   hint.flags = PPosition | PSize /* | PBaseSize */;
-   hint.base_width = hint.width; hint.base_height = hint.height;
-   XGetWindowAttributes(mDisplay, DefaultRootWindow(mDisplay), &attribs);
-   depth=attribs.depth;
-   if (depth != 15 && depth != 16 && depth != 24 && depth != 32) depth = 24;
-   XMatchVisualInfo(mDisplay, mScreen, depth, TrueColor, &vinfo);
-
-   xswa.background_pixel = 0;
-   xswa.border_pixel     = 0;
-   xswamask = CWBackPixel | CWBorderPixel;
-
-    if ( WinID>=0 ){
-      vo_window = WinID ? ((Window)WinID) : mRootWin;
-      if ( WinID ) 
-       {
-        XUnmapWindow( mDisplay,vo_window );
-        XChangeWindowAttributes( mDisplay,vo_window,xswamask,&xswa );
-	vo_x11_selectinput_witherr( mDisplay,vo_window,StructureNotifyMask | KeyPressMask | PropertyChangeMask | PointerMotionMask | ButtonPressMask | ButtonReleaseMask | ExposureMask );
-        XMapWindow( mDisplay,vo_window );
-       } else { drwX=vo_dx; drwY=vo_dy; }
-    } else 
-    if ( vo_window == None ){
-        vo_window = vo_x11_create_smooth_window(mDisplay, mRootWin, vinfo.visual, hint.x, hint.y, hint.width, hint.height, depth, CopyFromParent); 
-
-        vo_x11_classhint( mDisplay,vo_window,"xv" );
-        vo_hidecursor(mDisplay,vo_window);
-
-        vo_x11_selectinput_witherr(mDisplay, vo_window, StructureNotifyMask | KeyPressMask | PropertyChangeMask |
-	((WinID==0) ? 0 : (PointerMotionMask
-		| ButtonPressMask | ButtonReleaseMask | ExposureMask
-	  )));
-        XSetStandardProperties(mDisplay, vo_window, hello, hello, None, NULL, 0, &hint);
-        XSetWMNormalHints( mDisplay,vo_window,&hint );
-	XMapWindow(mDisplay, vo_window);
-	if ( flags&1 ) vo_x11_fullscreen();
-	else {
+        vo_dwidth = d_width;
+        vo_dheight = d_height;
+        hint.flags = PPosition | PSize /* | PBaseSize */ ;
+        hint.base_width = hint.width;
+        hint.base_height = hint.height;
+        XGetWindowAttributes(mDisplay, DefaultRootWindow(mDisplay),
+                             &attribs);
+        depth = attribs.depth;
+        if (depth != 15 && depth != 16 && depth != 24 && depth != 32)
+            depth = 24;
+        XMatchVisualInfo(mDisplay, mScreen, depth, TrueColor, &vinfo);
+
+        xswa.background_pixel = 0;
+        xswa.border_pixel = 0;
+        xswamask = CWBackPixel | CWBorderPixel;
+
+        if (WinID >= 0)
+        {
+            vo_window = WinID ? ((Window) WinID) : mRootWin;
+            if (WinID)
+            {
+                XUnmapWindow(mDisplay, vo_window);
+                XChangeWindowAttributes(mDisplay, vo_window, xswamask,
+                                        &xswa);
+                vo_x11_selectinput_witherr(mDisplay, vo_window,
+                                           StructureNotifyMask |
+                                           KeyPressMask |
+                                           PropertyChangeMask |
+                                           PointerMotionMask |
+                                           ButtonPressMask |
+                                           ButtonReleaseMask |
+                                           ExposureMask);
+                XMapWindow(mDisplay, vo_window);
+            } else
+            {
+                drwX = vo_dx;
+                drwY = vo_dy;
+            }
+        } else if (vo_window == None)
+        {
+            vo_window =
+                vo_x11_create_smooth_window(mDisplay, mRootWin,
+                                            vinfo.visual, hint.x, hint.y,
+                                            hint.width, hint.height, depth,
+                                            CopyFromParent);
+
+            vo_x11_classhint(mDisplay, vo_window, "xv");
+            vo_hidecursor(mDisplay, vo_window);
+
+            vo_x11_selectinput_witherr(mDisplay, vo_window,
+                                       StructureNotifyMask | KeyPressMask |
+                                       PropertyChangeMask | ((WinID == 0) ?
+                                                             0
+                                                             :
+                                                             (PointerMotionMask
+                                                              |
+                                                              ButtonPressMask
+                                                              |
+                                                              ButtonReleaseMask
+                                                              |
+                                                              ExposureMask)));
+            XSetStandardProperties(mDisplay, vo_window, hello, hello, None,
+                                   NULL, 0, &hint);
+            XSetWMNormalHints(mDisplay, vo_window, &hint);
+            XMapWindow(mDisplay, vo_window);
+            if (flags & 1)
+                vo_x11_fullscreen();
+            else
+            {
 #ifdef HAVE_XINERAMA
-	    vo_x11_xinerama_move(mDisplay,vo_window);
+                vo_x11_xinerama_move(mDisplay, vo_window);
 #endif
-		vo_x11_sizehint( hint.x, hint.y, hint.width, hint.height,0 );
-	}
-    } else  {
-	// vo_fs set means we were already at fullscreen
-	vo_x11_sizehint( hint.x, hint.y, hint.width, hint.height,0 );
-	if ( !vo_fs ) XMoveResizeWindow( mDisplay,vo_window,hint.x,hint.y,hint.width,hint.height );
-	if ( flags&1 && !vo_fs ) vo_x11_fullscreen(); // handle -fs on non-first file
-    }
-    
+                vo_x11_sizehint(hint.x, hint.y, hint.width, hint.height,
+                                0);
+            }
+        } else
+        {
+            // vo_fs set means we were already at fullscreen
+            vo_x11_sizehint(hint.x, hint.y, hint.width, hint.height, 0);
+            if (!vo_fs)
+                XMoveResizeWindow(mDisplay, vo_window, hint.x, hint.y,
+                                  hint.width, hint.height);
+            if (flags & 1 && !vo_fs)
+                vo_x11_fullscreen();    // handle -fs on non-first file
+        }
+
 //    vo_x11_sizehint( hint.x, hint.y, hint.width, hint.height,0 );   
-    
-    if ( vo_gc != None ) XFreeGC( mDisplay,vo_gc );
-    vo_gc = XCreateGC(mDisplay, vo_window, 0L, &xgcv);
-    XFlush(mDisplay);
-    XSync(mDisplay, False);
+
+        if (vo_gc != None)
+            XFreeGC(mDisplay, vo_gc);
+        vo_gc = XCreateGC(mDisplay, vo_window, 0L, &xgcv);
+        XFlush(mDisplay);
+        XSync(mDisplay, False);
 #ifdef HAVE_XF86VM
-    if ( vm )
-     {
-      /* Grab the mouse pointer in our window */
-      if(vo_grabpointer)
-      XGrabPointer(mDisplay, vo_window, True, 0,
-                   GrabModeAsync, GrabModeAsync,
-                   vo_window, None, CurrentTime);
-      XSetInputFocus(mDisplay, vo_window, RevertToNone, CurrentTime);
-     }
+        if (vm)
+        {
+            /* Grab the mouse pointer in our window */
+            if (vo_grabpointer)
+                XGrabPointer(mDisplay, vo_window, True, 0,
+                             GrabModeAsync, GrabModeAsync,
+                             vo_window, None, CurrentTime);
+            XSetInputFocus(mDisplay, vo_window, RevertToNone, CurrentTime);
+        }
 #endif
-  }
-
-     mp_msg(MSGT_VO,MSGL_V, "using Xvideo port %d for hw scaling\n",xv_port );
-       
-       switch (xv_format){
-	case IMGFMT_YV12:  
-	case IMGFMT_I420:
-        case IMGFMT_IYUV: draw_alpha_fnc=draw_alpha_yv12; break;
-	case IMGFMT_YUY2:
-	case IMGFMT_YVYU: draw_alpha_fnc=draw_alpha_yuy2; break;	
-	case IMGFMT_UYVY: draw_alpha_fnc=draw_alpha_uyvy; break;
-	default:   	  draw_alpha_fnc=draw_alpha_null;
-       }
-
-      if ( vo_config_count )
-        for(current_buf=0;current_buf<num_buffers;++current_buf)
-         deallocate_xvimage(current_buf);
-
-      for(current_buf=0;current_buf<num_buffers;++current_buf)
-       allocate_xvimage(current_buf);
-
-     current_buf=0;
-     current_ip_buf=0;
+    }
+
+    mp_msg(MSGT_VO, MSGL_V, "using Xvideo port %d for hw scaling\n",
+           xv_port);
+
+    switch (xv_format)
+    {
+        case IMGFMT_YV12:
+        case IMGFMT_I420:
+        case IMGFMT_IYUV:
+            draw_alpha_fnc = draw_alpha_yv12;
+            break;
+        case IMGFMT_YUY2:
+        case IMGFMT_YVYU:
+            draw_alpha_fnc = draw_alpha_yuy2;
+            break;
+        case IMGFMT_UYVY:
+            draw_alpha_fnc = draw_alpha_uyvy;
+            break;
+        default:
+            draw_alpha_fnc = draw_alpha_null;
+    }
+
+    if (vo_config_count)
+        for (current_buf = 0; current_buf < num_buffers; ++current_buf)
+            deallocate_xvimage(current_buf);
+
+    for (current_buf = 0; current_buf < num_buffers; ++current_buf)
+        allocate_xvimage(current_buf);
+
+    current_buf = 0;
+    current_ip_buf = 0;
 
 #if 0
-     set_gamma_correction();
+    set_gamma_correction();
 #endif
 
-     aspect(&vo_dwidth,&vo_dheight,A_NOZOOM);
-     if ( (( flags&1 )&&( WinID <= 0 )) || vo_fs )
-      {
-       aspect(&vo_dwidth,&vo_dheight,A_ZOOM);
-       drwX=( vo_screenwidth - (vo_dwidth > vo_screenwidth?vo_screenwidth:vo_dwidth) ) / 2;
-       drwY=( vo_screenheight - (vo_dheight > vo_screenheight?vo_screenheight:vo_dheight) ) / 2;
-       vo_dwidth=(vo_dwidth > vo_screenwidth?vo_screenwidth:vo_dwidth);
-       vo_dheight=(vo_dheight > vo_screenheight?vo_screenheight:vo_dheight);
-       mp_msg(MSGT_VO,MSGL_V, "[xv-fs] dx: %d dy: %d dw: %d dh: %d\n",drwX,drwY,vo_dwidth,vo_dheight );
-      }
+    aspect(&vo_dwidth, &vo_dheight, A_NOZOOM);
+    if (((flags & 1) && (WinID <= 0)) || vo_fs)
+    {
+        aspect(&vo_dwidth, &vo_dheight, A_ZOOM);
+        drwX =
+            (vo_screenwidth -
+             (vo_dwidth >
+              vo_screenwidth ? vo_screenwidth : vo_dwidth)) / 2;
+        drwY =
+            (vo_screenheight -
+             (vo_dheight >
+              vo_screenheight ? vo_screenheight : vo_dheight)) / 2;
+        vo_dwidth =
+            (vo_dwidth > vo_screenwidth ? vo_screenwidth : vo_dwidth);
+        vo_dheight =
+            (vo_dheight > vo_screenheight ? vo_screenheight : vo_dheight);
+        mp_msg(MSGT_VO, MSGL_V, "[xv-fs] dx: %d dy: %d dw: %d dh: %d\n",
+               drwX, drwY, vo_dwidth, vo_dheight);
+    }
 
-     panscan_calc();
+    panscan_calc();
 
-     XClearWindow(mDisplay, vo_window);
+    XClearWindow(mDisplay, vo_window);
 #if 0
 #ifdef HAVE_SHM
-     if ( Shmem_Flag )
-     {
-	 XvShmPutImage(mDisplay, xv_port, vo_window, vo_gc, xvimage[current_buf], 0, 0,  image_width, image_height, drwX, drwY, 1, 1, False);
-	 XvShmPutImage(mDisplay, xv_port, vo_window, vo_gc, xvimage[current_buf], 0, 0,  image_width, image_height, drwX,drwY,vo_dwidth,(vo_fs?vo_dheight - 1:vo_dheight), False);
-     }
-     else
+    if (Shmem_Flag)
+    {
+        XvShmPutImage(mDisplay, xv_port, vo_window, vo_gc,
+                      xvimage[current_buf], 0, 0, image_width,
+                      image_height, drwX, drwY, 1, 1, False);
+        XvShmPutImage(mDisplay, xv_port, vo_window, vo_gc,
+                      xvimage[current_buf], 0, 0, image_width,
+                      image_height, drwX, drwY, vo_dwidth,
+                      (vo_fs ? vo_dheight - 1 : vo_dheight), False);
+    } else
 #endif
-     {
-	 XvPutImage(mDisplay, xv_port, vo_window, vo_gc, xvimage[current_buf], 0, 0,  image_width, image_height, drwX, drwY, 1, 1);
-	 XvPutImage(mDisplay, xv_port, vo_window, vo_gc, xvimage[current_buf], 0, 0,  image_width, image_height, drwX,drwY,vo_dwidth,(vo_fs?vo_dheight - 1:vo_dheight));
-     }
+    {
+        XvPutImage(mDisplay, xv_port, vo_window, vo_gc,
+                   xvimage[current_buf], 0, 0, image_width, image_height,
+                   drwX, drwY, 1, 1);
+        XvPutImage(mDisplay, xv_port, vo_window, vo_gc,
+                   xvimage[current_buf], 0, 0, image_width, image_height,
+                   drwX, drwY, vo_dwidth,
+                   (vo_fs ? vo_dheight - 1 : vo_dheight));
+    }
 #endif
-     
-     mp_msg(MSGT_VO,MSGL_V, "[xv] dx: %d dy: %d dw: %d dh: %d\n",drwX,drwY,vo_dwidth,vo_dheight );
 
-     saver_off(mDisplay);  // turning off screen saver
+    mp_msg(MSGT_VO, MSGL_V, "[xv] dx: %d dy: %d dw: %d dh: %d\n", drwX,
+           drwY, vo_dwidth, vo_dheight);
 
-     if (vo_ontop) vo_x11_setlayer(mDisplay, vo_window, vo_ontop);
+    saver_off(mDisplay);        // turning off screen saver
 
-     return 0;
+    if (vo_ontop)
+        vo_x11_setlayer(mDisplay, vo_window, vo_ontop);
+
+    return 0;
 }
 
 static void allocate_xvimage(int foo)
 {
- /*
-  * allocate XvImages.  FIXME: no error checking, without
-  * mit-shm this will bomb... trzing to fix ::atmos
-  */
+    /*
+     * allocate XvImages.  FIXME: no error checking, without
+     * mit-shm this will bomb... trzing to fix ::atmos
+     */
 #ifdef HAVE_SHM
- if ( mLocalDisplay && XShmQueryExtension( mDisplay ) ) Shmem_Flag = 1;
- else
-  {
-   Shmem_Flag = 0;
-   mp_msg(MSGT_VO,MSGL_INFO, "Shared memory not supported\nReverting to normal Xv\n" );
-  }
- if ( Shmem_Flag ) 
-  {
-   xvimage[foo] = (XvImage *) XvShmCreateImage(mDisplay, xv_port, xv_format, NULL, image_width, image_height, &Shminfo[foo]);
-
-   Shminfo[foo].shmid    = shmget(IPC_PRIVATE, xvimage[foo]->data_size, IPC_CREAT | 0777);
-   Shminfo[foo].shmaddr  = (char *) shmat(Shminfo[foo].shmid, 0, 0);
-   Shminfo[foo].readOnly = False;
-
-   xvimage[foo]->data = Shminfo[foo].shmaddr;
-   XShmAttach(mDisplay, &Shminfo[foo]);
-   XSync(mDisplay, False);
-   shmctl(Shminfo[foo].shmid, IPC_RMID, 0);
-  }
- else
+    if (mLocalDisplay && XShmQueryExtension(mDisplay))
+        Shmem_Flag = 1;
+    else
+    {
+        Shmem_Flag = 0;
+        mp_msg(MSGT_VO, MSGL_INFO,
+               "Shared memory not supported\nReverting to normal Xv\n");
+    }
+    if (Shmem_Flag)
+    {
+        xvimage[foo] =
+            (XvImage *) XvShmCreateImage(mDisplay, xv_port, xv_format,
+                                         NULL, image_width, image_height,
+                                         &Shminfo[foo]);
+
+        Shminfo[foo].shmid =
+            shmget(IPC_PRIVATE, xvimage[foo]->data_size, IPC_CREAT | 0777);
+        Shminfo[foo].shmaddr = (char *) shmat(Shminfo[foo].shmid, 0, 0);
+        Shminfo[foo].readOnly = False;
+
+        xvimage[foo]->data = Shminfo[foo].shmaddr;
+        XShmAttach(mDisplay, &Shminfo[foo]);
+        XSync(mDisplay, False);
+        shmctl(Shminfo[foo].shmid, IPC_RMID, 0);
+    } else
 #endif
-  {
-    xvimage[foo] = (XvImage *) XvCreateImage(mDisplay, xv_port, xv_format, NULL, image_width, image_height);
-    xvimage[foo]->data = malloc(xvimage[foo]->data_size);
-    XSync(mDisplay,False);
-  }
- memset(xvimage[foo]->data,128,xvimage[foo]->data_size);
- return;
+    {
+        xvimage[foo] =
+            (XvImage *) XvCreateImage(mDisplay, xv_port, xv_format, NULL,
+                                      image_width, image_height);
+        xvimage[foo]->data = malloc(xvimage[foo]->data_size);
+        XSync(mDisplay, False);
+    }
+    memset(xvimage[foo]->data, 128, xvimage[foo]->data_size);
+    return;
 }
 
 static void deallocate_xvimage(int foo)
 {
 #ifdef HAVE_SHM
- if ( Shmem_Flag )
-  {
-   XShmDetach( mDisplay,&Shminfo[foo] );
-   shmdt( Shminfo[foo].shmaddr );
-  }
- else
+    if (Shmem_Flag)
+    {
+        XShmDetach(mDisplay, &Shminfo[foo]);
+        shmdt(Shminfo[foo].shmaddr);
+    } else
 #endif
-  {
-   free(xvimage[foo]->data);
-  }
- XFree(xvimage[foo]);
- 
- XFlush( mDisplay );
- XSync(mDisplay, False);
- return;
+    {
+        free(xvimage[foo]->data);
+    }
+    XFree(xvimage[foo]);
+
+    XFlush(mDisplay);
+    XSync(mDisplay, False);
+    return;
 }
 
 static void check_events(void)
 {
- int e=vo_x11_check_events(mDisplay);
+    int e = vo_x11_check_events(mDisplay);
 
- if (e&VO_EVENT_EXPOSE && vo_fs)
-           vo_x11_clearwindow(mDisplay, vo_window);
+    if (e & VO_EVENT_EXPOSE && vo_fs)
+        vo_x11_clearwindow(mDisplay, vo_window);
 
- if(e&VO_EVENT_RESIZE)
-  {
-      if (vo_fs) {
-        e |= VO_EVENT_EXPOSE;
-        XClearWindow(mDisplay, vo_window);
-        XFlush(mDisplay);
-      }
-      
-   XGetGeometry( mDisplay,vo_window,&mRoot,&drwX,&drwY,&vo_dwidth,&vo_dheight,&drwBorderWidth,&drwDepth );
-   drwX = drwY = 0;
-   mp_msg(MSGT_VO,MSGL_V, "[xv] dx: %d dy: %d dw: %d dh: %d\n",drwX,drwY,vo_dwidth,vo_dheight );
-
-   aspect(&dwidth,&dheight,A_NOZOOM);
-   if ( vo_fs )
+    if (e & VO_EVENT_RESIZE)
     {
-     aspect(&dwidth,&dheight,A_ZOOM);
-     drwX=( vo_screenwidth - (dwidth > vo_screenwidth?vo_screenwidth:dwidth) ) / 2;
-     drwY=( vo_screenheight - (dheight > vo_screenheight?vo_screenheight:dheight) ) / 2;
-     vo_dwidth=(dwidth > vo_screenwidth?vo_screenwidth:dwidth);
-     vo_dheight=(dheight > vo_screenheight?vo_screenheight:dheight);
-     mp_msg(MSGT_VO,MSGL_V, "[xv-fs] dx: %d dy: %d dw: %d dh: %d\n",drwX,drwY,vo_dwidth,vo_dheight );
+        if (vo_fs)
+        {
+            e |= VO_EVENT_EXPOSE;
+            XClearWindow(mDisplay, vo_window);
+            XFlush(mDisplay);
+        }
+
+        XGetGeometry(mDisplay, vo_window, &mRoot, &drwX, &drwY, &vo_dwidth,
+                     &vo_dheight, &drwBorderWidth, &drwDepth);
+        drwX = drwY = 0;
+        mp_msg(MSGT_VO, MSGL_V, "[xv] dx: %d dy: %d dw: %d dh: %d\n", drwX,
+               drwY, vo_dwidth, vo_dheight);
+
+        aspect(&dwidth, &dheight, A_NOZOOM);
+        if (vo_fs)
+        {
+            aspect(&dwidth, &dheight, A_ZOOM);
+            drwX =
+                (vo_screenwidth -
+                 (dwidth > vo_screenwidth ? vo_screenwidth : dwidth)) / 2;
+            drwY =
+                (vo_screenheight -
+                 (dheight >
+                  vo_screenheight ? vo_screenheight : dheight)) / 2;
+            vo_dwidth =
+                (dwidth > vo_screenwidth ? vo_screenwidth : dwidth);
+            vo_dheight =
+                (dheight > vo_screenheight ? vo_screenheight : dheight);
+            mp_msg(MSGT_VO, MSGL_V,
+                   "[xv-fs] dx: %d dy: %d dw: %d dh: %d\n", drwX, drwY,
+                   vo_dwidth, vo_dheight);
+        }
     }
-  }
 
- if ( (e&VO_EVENT_EXPOSE || e&VO_EVENT_RESIZE) && int_pause)
-          flip_page();
+    if ((e & VO_EVENT_EXPOSE || e & VO_EVENT_RESIZE) && int_pause)
+        flip_page();
 }
 
 static void draw_osd(void)
-{ vo_draw_text(image_width-image_width*vo_panscan_x/(vo_dwidth+vo_panscan_x),image_height,draw_alpha_fnc);}
+{
+    vo_draw_text(image_width -
+                 image_width * vo_panscan_x / (vo_dwidth + vo_panscan_x),
+                 image_height, draw_alpha_fnc);
+}
 
 static void flip_page(void)
 {
 
 #ifdef HAVE_SHM
- if ( Shmem_Flag )
-  {
-   XvShmPutImage(mDisplay, xv_port, vo_window, vo_gc, xvimage[current_buf],
-         0, 0,  image_width, image_height,
-         drwX-(vo_panscan_x>>1),drwY-(vo_panscan_y>>1),vo_dwidth+vo_panscan_x,(vo_fs?vo_dheight - 1:vo_dheight)+vo_panscan_y,
-         False);
-  }
- else
+    if (Shmem_Flag)
+    {
+        XvShmPutImage(mDisplay, xv_port, vo_window, vo_gc,
+                      xvimage[current_buf], 0, 0, image_width,
+                      image_height, drwX - (vo_panscan_x >> 1),
+                      drwY - (vo_panscan_y >> 1), vo_dwidth + vo_panscan_x,
+                      (vo_fs ? vo_dheight - 1 : vo_dheight) + vo_panscan_y,
+                      False);
+    } else
 #endif
-  {
-   XvPutImage(mDisplay, xv_port, vo_window, vo_gc, xvimage[current_buf],
-         0, 0,  image_width, image_height,
-         drwX-(vo_panscan_x>>1),drwY-(vo_panscan_y>>1),vo_dwidth+vo_panscan_x,(vo_fs?vo_dheight - 1:vo_dheight)+vo_panscan_y);
-  }
- if (num_buffers>1){
-    current_buf=vo_directrendering?0:((current_buf+1)%num_buffers);
-    XFlush(mDisplay);
- } else
-    XSync(mDisplay, False);   
- return;
+    {
+        XvPutImage(mDisplay, xv_port, vo_window, vo_gc,
+                   xvimage[current_buf], 0, 0, image_width, image_height,
+                   drwX - (vo_panscan_x >> 1), drwY - (vo_panscan_y >> 1),
+                   vo_dwidth + vo_panscan_x,
+                   (vo_fs ? vo_dheight - 1 : vo_dheight) + vo_panscan_y);
+    }
+    if (num_buffers > 1)
+    {
+        current_buf =
+            vo_directrendering ? 0 : ((current_buf + 1) % num_buffers);
+        XFlush(mDisplay);
+    } else
+        XSync(mDisplay, False);
+    return;
 }
 
-static uint32_t draw_slice(uint8_t *image[], int stride[], int w,int h,int x,int y)
+static uint32_t draw_slice(uint8_t * image[], int stride[], int w, int h,
+                           int x, int y)
 {
- uint8_t *dst;
-
- dst = xvimage[current_buf]->data + xvimage[current_buf]->offsets[0] + 
-       xvimage[current_buf]->pitches[0]*y + x;
- memcpy_pic(dst, image[0], w, h, xvimage[current_buf]->pitches[0], stride[0]);
-
- x/=2;y/=2;w/=2;h/=2;
-
- dst = xvimage[current_buf]->data + xvimage[current_buf]->offsets[1] + 
-       xvimage[current_buf]->pitches[1]*y + x;
- if(image_format!=IMGFMT_YV12)
-   memcpy_pic(dst, image[1], w, h, xvimage[current_buf]->pitches[1], stride[1]);
- else
-   memcpy_pic(dst, image[2], w, h, xvimage[current_buf]->pitches[1], stride[2]);
-
- dst = xvimage[current_buf]->data + xvimage[current_buf]->offsets[2] + 
-       xvimage[current_buf]->pitches[2]*y + x;
- if(image_format==IMGFMT_YV12)
-   memcpy_pic(dst, image[1], w, h, xvimage[current_buf]->pitches[1], stride[1]);
- else
-   memcpy_pic(dst, image[2], w, h, xvimage[current_buf]->pitches[1], stride[2]);
+    uint8_t *dst;
+
+    dst = xvimage[current_buf]->data + xvimage[current_buf]->offsets[0] +
+        xvimage[current_buf]->pitches[0] * y + x;
+    memcpy_pic(dst, image[0], w, h, xvimage[current_buf]->pitches[0],
+               stride[0]);
+
+    x /= 2;
+    y /= 2;
+    w /= 2;
+    h /= 2;
+
+    dst = xvimage[current_buf]->data + xvimage[current_buf]->offsets[1] +
+        xvimage[current_buf]->pitches[1] * y + x;
+    if (image_format != IMGFMT_YV12)
+        memcpy_pic(dst, image[1], w, h, xvimage[current_buf]->pitches[1],
+                   stride[1]);
+    else
+        memcpy_pic(dst, image[2], w, h, xvimage[current_buf]->pitches[1],
+                   stride[2]);
+
+    dst = xvimage[current_buf]->data + xvimage[current_buf]->offsets[2] +
+        xvimage[current_buf]->pitches[2] * y + x;
+    if (image_format == IMGFMT_YV12)
+        memcpy_pic(dst, image[1], w, h, xvimage[current_buf]->pitches[1],
+                   stride[1]);
+    else
+        memcpy_pic(dst, image[2], w, h, xvimage[current_buf]->pitches[1],
+                   stride[2]);
 
- return 0;
+    return 0;
 }
 
-static uint32_t draw_frame(uint8_t *src[]){
+static uint32_t draw_frame(uint8_t * src[])
+{
     printf("draw_frame() called!!!!!!");
     return -1;
 }
 
-static uint32_t draw_image(mp_image_t *mpi){
-    if(mpi->flags&MP_IMGFLAG_DIRECT){
-	// direct rendering:
-	current_buf=(int)(mpi->priv);	// hack!
-	return VO_TRUE;
+static uint32_t draw_image(mp_image_t * mpi)
+{
+    if (mpi->