Cosmetics: rename variables etc. in vo_direct3d.c

Patch by Georgi Petrov (gogothebee gmail com)


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

1 files changed, 225 insertions, 253 deletions

diff --git a/libvo/vo_direct3d.c b/libvo/vo_direct3d.c
index bca138eed4..39170ab171 100644
--- a/libvo/vo_direct3d.c
+++ b/libvo/vo_direct3d.c
@@ -46,53 +46,54 @@ static const vo_info_t info =
 const LIBVO_EXTERN(direct3d)
 
 
-/* Global variables. Each one starts with "g". Pointers include "p".
- * I try to keep their count low.
+/* Global variables "priv" structure. I try to keep their count low.
  */
-
-static int gIsPaused;               /**< 1 = Movie is paused,
-                                  0 = Movie is not paused */
-static int gIsD3DConfigFinished;    /**< Synchronization "semaphore". 1 when
-                                  instance of D3DConfigure is finished */
-static int gIsPanscan;              /**< 1= Panscan enabled, 0 = Panscan disabled */
-static RECT gFullScrMovieRect;      /**< Rect (upscaled) of the movie when displayed
-                                  in fullscreen */
-static RECT gPanScanSrcRect;        /**< PanScan source surface cropping in
-                                  fullscreen */
-static int gSrcWidth;               /**< Source (movie) width */
-static int gSrcHeight;              /**< Source (movie) heigth */
-static LPDIRECT3D9 gpD3DHandle;         /**< Direct3D Handle */
-static LPDIRECT3DDEVICE9  gpD3DDevice;  /**< The Direct3D Adapter */
-static IDirect3DSurface9 *gpD3DSurface; /**< Offscreen Direct3D Surface. MPlayer
-                                      renders inside it. Uses colorspace
-                                      MovieSrcFmt */
-static IDirect3DSurface9 *gpD3DBackBuf; /**< Video card's back buffer (used to
-                                      display next frame) */
-static D3DFORMAT gMovieSrcFmt;          /**< Movie colorspace format (depends on
-                                      the movie's codec) */
-static D3DFORMAT gDesktopFmt;           /**< Desktop (screen) colorspace format.
-                                      Usually XRGB */
-typedef struct
-{
-    const unsigned int  MPlayerFormat; /**< Given by MPlayer */
-    const D3DFORMAT     FourCC;        /**< Required by D3D's test function */
-} DisplayFormatTable;
+static struct global_priv {
+    int is_paused;              /**< 1 = Movie is paused,
+                                0 = Movie is not paused */
+    int is_cfg_finished;        /**< Synchronization "semaphore". 1 when
+                                instance of reconfigure_d3d is finished */
+    int is_panscan;             /**< 1= Panscan enabled, 0 = Panscan disabled */
+
+    RECT fs_movie_rect;         /**< Rect (upscaled) of the movie when displayed
+                                in fullscreen */
+    RECT fs_panscan_rect;       /**< PanScan source surface cropping in
+                                fullscreen */
+    int src_width;              /**< Source (movie) width */
+    int src_height;             /**< Source (movie) heigth */
+
+    D3DFORMAT movie_src_fmt;        /**< Movie colorspace format (depends on
+                                    the movie's codec) */
+    D3DFORMAT desktop_fmt;          /**< Desktop (screen) colorspace format.
+                                    Usually XRGB */
+    LPDIRECT3D9        d3d_handle;  /**< Direct3D Handle */
+    LPDIRECT3DDEVICE9  d3d_device;  /**< The Direct3D Adapter */
+    IDirect3DSurface9 *d3d_surface; /**< Offscreen Direct3D Surface. MPlayer
+                                    renders inside it. Uses colorspace
+                                    priv->movie_src_fmt */
+    IDirect3DSurface9 *d3d_backbuf; /**< Video card's back buffer (used to
+                                    display next frame) */
+} *priv;
+
+typedef struct {
+    const unsigned int  mplayer_fmt;   /**< Given by MPlayer */
+    const D3DFORMAT     fourcc;        /**< Required by D3D's test function */
+} struct_fmt_table;
 
 /* Map table from reported MPlayer format to the required
-   FourCC. This is needed to perform the format query. */
+   fourcc. This is needed to perform the format query. */
 
-static const DisplayFormatTable gDisplayFormatTable[] =
-{
+static const struct_fmt_table fmt_table[] = {
     {IMGFMT_YV12, MAKEFOURCC('Y','V','1','2')},
     {IMGFMT_I420, MAKEFOURCC('I','4','2','0')},
     {IMGFMT_IYUV, MAKEFOURCC('I','Y','U','V')},
     {IMGFMT_YVU9, MAKEFOURCC('Y','V','U','9')},
     {IMGFMT_YUY2, MAKEFOURCC('Y','U','Y','2')},
-    {IMGFMT_UYVY, MAKEFOURCC('U','Y','V','Y')}
+    {IMGFMT_UYVY, MAKEFOURCC('U','Y','V','Y')},
 };
 
 #define DISPLAY_FORMAT_TABLE_ENTRIES \
-        (sizeof(gDisplayFormatTable) / sizeof(gDisplayFormatTable[0]))
+        (sizeof(fmt_table) / sizeof(fmt_table[0]))
 
 /****************************************************************************
  *                                                                          *
@@ -106,108 +107,105 @@ static const DisplayFormatTable gDisplayFormatTable[] =
 
 /** @brief Calculate panscan source RECT in fullscreen.
  */
-static void CalculatePanscanRect (void)
+static void calc_panscan_rect(void)
 {
-    int scaledHeight = 0;
-    int scaledWidth = 0;
+    int scaled_height = 0;
+    int scaled_width = 0;
     int srcPanx;
     int srcPany;
 
-    mp_msg(MSGT_VO,MSGL_ERR,"<vo_direct3d>CalculatePanscanRect called\r\n");
+    mp_msg(MSGT_VO,MSGL_ERR,"<vo_direct3d>calc_panscan_rect called\r\n");
 
-    aspect(&scaledWidth, &scaledHeight, A_ZOOM);
+    aspect(&scaled_width, &scaled_height, A_ZOOM);
     panscan_calc();
 
-    if (vo_panscan_x != 0 || vo_panscan_y != 0)
-    {
-        gIsPanscan = 1;
+    if (vo_panscan_x != 0 || vo_panscan_y != 0) {
+        priv->is_panscan = 1;
         mp_msg(MSGT_VO,MSGL_V,
               "<vo_direct3d>Panscan destination correction: x: %d, y: %d\r\n",
               vo_panscan_x, vo_panscan_y);
 
         mp_msg(MSGT_VO,MSGL_V,
-              "<vo_direct3d>vo_panscan_x %d, scaledWidth %d, vo_screenwidth %d\r\n",
-              vo_panscan_x, scaledWidth, vo_screenwidth);
+              "<vo_direct3d>vo_panscan_x %d, scaled_width %d, vo_screenwidth %d\r\n",
+              vo_panscan_x, scaled_width, vo_screenwidth);
 
         mp_msg(MSGT_VO,MSGL_V,
-              "<vo_direct3d>vo_panscan_y %d, scaledHeight %d, vo_screenheight %d\r\n",
-              vo_panscan_y, scaledHeight, vo_screenheight);
+              "<vo_direct3d>vo_panscan_y %d, scaled_height %d, vo_screenheight %d\r\n",
+              vo_panscan_y, scaled_height, vo_screenheight);
 
-        srcPanx = vo_panscan_x / (vo_screenwidth / scaledWidth);
-        srcPany = vo_panscan_y / (vo_screenheight / scaledHeight);
+        srcPanx = vo_panscan_x / (vo_screenwidth / scaled_width);
+        srcPany = vo_panscan_y / (vo_screenheight / scaled_height);
 
         mp_msg(MSGT_VO,MSGL_V,
               "<vo_direct3d>Panscan source (needed) correction: x: %d, y: %d\r\n",
               srcPanx, srcPany);
 
-        gPanScanSrcRect.left   = srcPanx / 2;
-        if (gPanScanSrcRect.left % 2 != 0) gPanScanSrcRect.left++;
-        gPanScanSrcRect.right  = gSrcWidth - (srcPanx / 2);
-        if (gPanScanSrcRect.right % 2 != 0) gPanScanSrcRect.right--;
-        gPanScanSrcRect.top    = srcPany / 2;
-        if (gPanScanSrcRect.top % 2 != 0) gPanScanSrcRect.top++;
-        gPanScanSrcRect.bottom = gSrcHeight - (srcPany / 2);
-        if (gPanScanSrcRect.bottom % 2 != 0) gPanScanSrcRect.bottom--;
+        priv->fs_panscan_rect.left   = srcPanx / 2;
+        if (priv->fs_panscan_rect.left % 2 != 0) priv->fs_panscan_rect.left++;
+        priv->fs_panscan_rect.right  = priv->src_width - (srcPanx / 2);
+        if (priv->fs_panscan_rect.right % 2 != 0) priv->fs_panscan_rect.right--;
+        priv->fs_panscan_rect.top    = srcPany / 2;
+        if (priv->fs_panscan_rect.top % 2 != 0) priv->fs_panscan_rect.top++;
+        priv->fs_panscan_rect.bottom = priv->src_height - (srcPany / 2);
+        if (priv->fs_panscan_rect.bottom % 2 != 0) priv->fs_panscan_rect.bottom--;
 
         mp_msg(MSGT_VO,MSGL_V,
         "<vo_direct3d>Panscan Source Rect: t: %ld, l: %ld, r: %ld, b:%ld\r\n",
-        gPanScanSrcRect.top, gPanScanSrcRect.left,
-        gPanScanSrcRect.right, gPanScanSrcRect.bottom);
+        priv->fs_panscan_rect.top, priv->fs_panscan_rect.left,
+        priv->fs_panscan_rect.right, priv->fs_panscan_rect.bottom);
     }
     else
-        gIsPanscan = 0;
+        priv->is_panscan = 0;
 }
 
 /** @brief Calculate scaled fullscreen movie rectangle with
  *  preserved aspect ratio.
  */
-static void CalculateFullscreenRect (void)
+static void calc_fs_rect(void)
 {
-    int scaledHeight = 0;
-    int scaledWidth = 0;
+    int scaled_height = 0;
+    int scaled_width = 0;
     /* If we've created fullscreen context, we should calculate stretched
     * movie RECT, otherwise it will fill the whole fullscreen with
     * wrong aspect ratio */
 
-    aspect(&scaledWidth, &scaledHeight, A_ZOOM);
+    aspect(&scaled_width, &scaled_height, A_ZOOM);
 
-    gFullScrMovieRect.left   = (vo_screenwidth - scaledWidth) / 2;
-    gFullScrMovieRect.right  = gFullScrMovieRect.left + scaledWidth;
-    gFullScrMovieRect.top    = (vo_screenheight - scaledHeight) / 2;
-    gFullScrMovieRect.bottom = gFullScrMovieRect.top + scaledHeight;
+    priv->fs_movie_rect.left   = (vo_screenwidth - scaled_width) / 2;
+    priv->fs_movie_rect.right  = priv->fs_movie_rect.left + scaled_width;
+    priv->fs_movie_rect.top    = (vo_screenheight - scaled_height) / 2;
+    priv->fs_movie_rect.bottom = priv->fs_movie_rect.top + scaled_height;
 
     mp_msg(MSGT_VO,MSGL_V,
     "<vo_direct3d>Fullscreen Movie Rect: t: %ld, l: %ld, r: %ld, b:%ld\r\n",
-        gFullScrMovieRect.top, gFullScrMovieRect.left,
-        gFullScrMovieRect.right, gFullScrMovieRect.bottom);
+        priv->fs_movie_rect.top, priv->fs_movie_rect.left,
+        priv->fs_movie_rect.right, priv->fs_movie_rect.bottom);
 
-    /*CalculatePanscanRect();*/
+    /*calc_panscan_rect();*/
 }
 
 /** @brief Destroy D3D Context related to the current window.
  */
-static void D3DDestroyContext (void)
+static void destroy_d3d_context(void)
 {
-    mp_msg(MSGT_VO,MSGL_V,"<vo_direct3d>D3DDestroyContext called\r\n");
+    mp_msg(MSGT_VO,MSGL_V,"<vo_direct3d>destroy_d3d_context called\r\n");
     /* Let's destroy the old (if any) D3D Content */
 
-    if (gpD3DSurface != NULL)
-    {
-        IDirect3DSurface9_Release (gpD3DSurface);
-        gpD3DSurface = NULL;
+    if (priv->d3d_surface != NULL) {
+        IDirect3DSurface9_Release (priv->d3d_surface);
+        priv->d3d_surface = NULL;
     }
 
-    if (gpD3DDevice != NULL)
-    {
-        IDirect3DDevice9_Release (gpD3DDevice);
-        gpD3DDevice = NULL;
+    if (priv->d3d_device != NULL) {
+        IDirect3DDevice9_Release (priv->d3d_device);
+        priv->d3d_device = NULL;
     }
 
-    /* The following is not a memory leak. pD3DBackBuf is not malloc'ed
+    /* The following is not a memory leak. d3d_backbuf is not malloc'ed
      * but just holds a pointer to the back buffer. Nobody gets hurt from
      * setting it to NULL.
      */
-    gpD3DBackBuf = NULL;
+    priv->d3d_backbuf = NULL;
 }
 
 
@@ -215,51 +213,49 @@ static void D3DDestroyContext (void)
  *  The first function called to initialize D3D context.
  *  @return 1 on success, 0 on failure
  */
-static int D3DConfigure (void)
+static int reconfigure_d3d(void)
 {
-    D3DPRESENT_PARAMETERS PresentParams;
-    D3DDISPLAYMODE DisplayMode;
+    D3DPRESENT_PARAMETERS present_params;
+    D3DDISPLAYMODE disp_mode;
 
-    mp_msg(MSGT_VO,MSGL_V,"<vo_direct3d><INFO>D3DConfigure CALLED\n");
+    mp_msg(MSGT_VO,MSGL_V,"<vo_direct3d><INFO>reconfigure_d3d called \n");
 
-    D3DDestroyContext();
+    destroy_d3d_context();
 
     /* Get the current desktop display mode, so we can set up a back buffer
      * of the same format. */
-    if (FAILED (IDirect3D9_GetAdapterDisplayMode (gpD3DHandle,
-                                                  D3DADAPTER_DEFAULT,
-                                                  &DisplayMode)))
-    {
+    if (FAILED(IDirect3D9_GetAdapterDisplayMode(priv->d3d_handle,
+                                                D3DADAPTER_DEFAULT,
+                                                &disp_mode))) {
         mp_msg(MSGT_VO,MSGL_ERR,
                "<vo_direct3d><INFO>Could not read adapter display mode.\n");
         return 0;
     }
 
     /* Write current Desktop's colorspace format in the global storage. */
-    gDesktopFmt = DisplayMode.Format;
+    priv->desktop_fmt = disp_mode.Format;
 
     /* Prepare Direct3D initialization parameters. */
-    memset(&PresentParams, 0, sizeof(D3DPRESENT_PARAMETERS));
-    PresentParams.Windowed               = TRUE;
-    PresentParams.SwapEffect             = D3DSWAPEFFECT_COPY;
-    PresentParams.Flags                  = D3DPRESENTFLAG_VIDEO;
-    PresentParams.hDeviceWindow          = vo_w32_window; /* w32_common var */
-    PresentParams.BackBufferWidth        = 0; /* Fill up window Width */
-    PresentParams.BackBufferHeight       = 0; /* Fill up window Height */
-    PresentParams.MultiSampleType        = D3DMULTISAMPLE_NONE;
+    memset(&present_params, 0, sizeof(D3DPRESENT_PARAMETERS));
+    present_params.Windowed               = TRUE;
+    present_params.SwapEffect             = D3DSWAPEFFECT_COPY;
+    present_params.Flags                  = D3DPRESENTFLAG_VIDEO;
+    present_params.hDeviceWindow          = vo_w32_window; /* w32_common var */
+    present_params.BackBufferWidth        = 0; /* Fill up window Width */
+    present_params.BackBufferHeight       = 0; /* Fill up window Height */
+    present_params.MultiSampleType        = D3DMULTISAMPLE_NONE;
     /* D3DPRESENT_INTERVAL_ONE = vsync */
-    PresentParams.PresentationInterval   = D3DPRESENT_INTERVAL_ONE;
-    PresentParams.BackBufferFormat       = gDesktopFmt;
-    PresentParams.BackBufferCount        = 1;
-    PresentParams.EnableAutoDepthStencil = FALSE;
+    present_params.PresentationInterval   = D3DPRESENT_INTERVAL_ONE;
+    present_params.BackBufferFormat       = priv->desktop_fmt;
+    present_params.BackBufferCount        = 1;
+    present_params.EnableAutoDepthStencil = FALSE;
 
     /* vo_w32_window is w32_common variable. It's a handle to the window. */
-    if (FAILED (IDirect3D9_CreateDevice(gpD3DHandle,
+    if (FAILED(IDirect3D9_CreateDevice(priv->d3d_handle,
                                      D3DADAPTER_DEFAULT,
                                      D3DDEVTYPE_HAL, vo_w32_window,
                                      D3DCREATE_SOFTWARE_VERTEXPROCESSING,
-                                     &PresentParams, &gpD3DDevice)))
-    {
+                                     &present_params, &priv->d3d_device))) {
         mp_msg(MSGT_VO,MSGL_ERR,
                "<vo_direct3d><INFO>Could not create the D3D device\n");
         return 0;
@@ -267,53 +263,50 @@ static int D3DConfigure (void)
 
     mp_msg(MSGT_VO,MSGL_V,
       "New BackBuffer: Width: %d, Height:%d. VO Dest Width:%d, Height: %d\n",
-          PresentParams.BackBufferWidth, PresentParams.BackBufferHeight,
+          present_params.BackBufferWidth, present_params.BackBufferHeight,
           vo_dwidth, vo_dheight);
 
-    if (FAILED (IDirect3DDevice9_CreateOffscreenPlainSurface(
-         gpD3DDevice, gSrcWidth, gSrcHeight,
-         gMovieSrcFmt, D3DPOOL_DEFAULT, &gpD3DSurface, NULL)))
-    {
+    if (FAILED(IDirect3DDevice9_CreateOffscreenPlainSurface(
+         priv->d3d_device, priv->src_width, priv->src_height,
+         priv->movie_src_fmt, D3DPOOL_DEFAULT, &priv->d3d_surface, NULL))) {
         mp_msg(MSGT_VO,MSGL_ERR,
         "<vo_direct3d><INFO>IDirect3D9_CreateOffscreenPlainSurface Failed.\n");
         return 0;
     }
 
-    if (FAILED (IDirect3DDevice9_GetBackBuffer (gpD3DDevice, 0, 0,
-                                                D3DBACKBUFFER_TYPE_MONO,
-                                                &(gpD3DBackBuf))))
-    {
+    if (FAILED(IDirect3DDevice9_GetBackBuffer(priv->d3d_device, 0, 0,
+                                              D3DBACKBUFFER_TYPE_MONO,
+                                              &(priv->d3d_backbuf)))) {
         mp_msg(MSGT_VO,MSGL_ERR,"<vo_direct3d>Back Buffer address get failed\n");
         return 0;
     }
 
     /* Fill the Surface with black color. */
-    IDirect3DDevice9_ColorFill(gpD3DDevice, gpD3DSurface, NULL,
+    IDirect3DDevice9_ColorFill(priv->d3d_device, priv->d3d_surface, NULL,
                                D3DCOLOR_ARGB(0xFF, 0, 0, 0) );
 
     if (vo_fs)
-        CalculateFullscreenRect ();
+        calc_fs_rect();
 
     return 1;
 }
 
 /** @brief Uninitialize Direct3D and close the window.
  */
-static void D3DUninit(void)
+static void uninit_d3d(void)
 {
-    mp_msg(MSGT_VO,MSGL_V,"<vo_direct3d>D3DUninit called\r\n");
+    mp_msg(MSGT_VO,MSGL_V,"<vo_direct3d>uninit_d3d called\r\n");
 
-    /* Block further calls to D3DConfigure(). */
-    gIsD3DConfigFinished = 0;
+    /* Block further calls to reconfigure_d3d(). */
+    priv->is_cfg_finished = 0;
 
     /* Destroy D3D Context inside the window. */
-    D3DDestroyContext();
+    destroy_d3d_context();
 
     /* Stop the whole D3D. */
-    if (NULL != gpD3DHandle)
-    {
+    if (NULL != priv->d3d_handle) {
         mp_msg(MSGT_VO,MSGL_V,"<vo_direct3d>Calling IDirect3D9_Release\r\n");
-        IDirect3D9_Release (gpD3DHandle);
+        IDirect3D9_Release(priv->d3d_handle);
     }
 }
 
@@ -321,9 +314,9 @@ static void D3DUninit(void)
  *  @param mpi mpi structure with the decoded frame inside
  *  @return VO_TRUE on success, VO_ERROR on failure
  */
-static uint32_t D3DRenderFrame (mp_image_t *mpi)
+static uint32_t render_d3d_frame(mp_image_t *mpi)
 {
-    D3DLOCKED_RECT  stLockedRect;   /**< Offscreen surface we lock in order
+    D3DLOCKED_RECT  locked_rect;   /**< Offscreen surface we lock in order
                                          to copy MPlayer's frame inside it.*/
 
     /* Uncomment when direct rendering is implemented.
@@ -333,51 +326,45 @@ static uint32_t D3DRenderFrame (mp_image_t *mpi)
     if (mpi->flags & MP_IMGFLAG_DRAW_CALLBACK)
         return VO_TRUE;
 
-    if (mpi->flags & MP_IMGFLAG_PLANAR)
-    { /* Copy a planar frame. */
+    if (mpi->flags & MP_IMGFLAG_PLANAR) { /* Copy a planar frame. */
         draw_slice(mpi->planes,mpi->stride,mpi->w,mpi->h,0,0);
         return VO_TRUE;
     }
 
     /* If the previous if failed, we should draw a packed frame */
-    if (FAILED (IDirect3DDevice9_BeginScene(gpD3DDevice)))
-    {
+    if (FAILED(IDirect3DDevice9_BeginScene(priv->d3d_device))) {
        mp_msg(MSGT_VO,MSGL_ERR,"<vo_direct3d>BeginScene failed\n");
        return VO_ERROR;
     }
 
-    if (FAILED (IDirect3DSurface9_LockRect(gpD3DSurface,
-                                           &stLockedRect, NULL, 0)))
-    {
+    if (FAILED(IDirect3DSurface9_LockRect(priv->d3d_surface,
+                                           &locked_rect, NULL, 0))) {
        mp_msg(MSGT_VO,MSGL_ERR,"<vo_direct3d>Surface lock failure\n");
        return VO_ERROR;
     }
 
-    memcpy_pic(stLockedRect.pBits, mpi->planes[0], mpi->stride[0],
-               mpi->height, stLockedRect.Pitch, mpi->stride[0]);
+    memcpy_pic(locked_rect.pBits, mpi->planes[0], mpi->stride[0],
+               mpi->height, locked_rect.Pitch, mpi->stride[0]);
 
-    if (FAILED (IDirect3DSurface9_UnlockRect(gpD3DSurface)))
-    {
+    if (FAILED(IDirect3DSurface9_UnlockRect(priv->d3d_surface))) {
         mp_msg(MSGT_VO,MSGL_V,"<vo_direct3d>Surface unlock failure\n");
         return VO_ERROR;
     }
 
-    if (FAILED (IDirect3DDevice9_StretchRect (gpD3DDevice,
-                                              gpD3DSurface,
-                                              gIsPanscan ?
-                                              &gPanScanSrcRect : NULL,
-                                              gpD3DBackBuf,
-                                              vo_fs ?
-                                              &gFullScrMovieRect : NULL,
-                                              D3DTEXF_LINEAR)))
-    {
+    if (FAILED(IDirect3DDevice9_StretchRect(priv->d3d_device,
+                                            priv->d3d_surface,
+                                            priv->is_panscan ?
+                                            &priv->fs_panscan_rect : NULL,
+                                            priv->d3d_backbuf,
+                                            vo_fs ?
+                                            &priv->fs_movie_rect : NULL,
+                                            D3DTEXF_LINEAR))) {
         mp_msg(MSGT_VO,MSGL_ERR,
                "<vo_direct3d>Unable to copy the frame to the back buffer\n");
         return VO_ERROR;
     }
 
-    if (FAILED (IDirect3DDevice9_EndScene(gpD3DDevice)))
-    {
+    if (FAILED(IDirect3DDevice9_EndScene(priv->d3d_device))) {
        mp_msg(MSGT_VO,MSGL_ERR,"<vo_direct3d>EndScene failed\n");
        return VO_ERROR;
     }
@@ -390,26 +377,28 @@ static uint32_t D3DRenderFrame (mp_image_t *mpi)
  *  @return 0 on failure, device capabilities (not probed
  *          currently) on success.
  */
-static int query_format (uint32_t MovieFormat)
+static int query_format(uint32_t movie_fmt)
 {
     int i;
-    for (i=0; i < DISPLAY_FORMAT_TABLE_ENTRIES; i++)
-    {
-        if (gDisplayFormatTable[i].MPlayerFormat == MovieFormat)
-        {
+    for (i=0; i < DISPLAY_FORMAT_TABLE_ENTRIES; i++) {
+        if (fmt_table[i].mplayer_fmt == movie_fmt) {
             /* Test conversion from Movie colorspace to
              * display's target colorspace. */
-            if (FAILED (IDirect3D9_CheckDeviceFormatConversion(
-                                           gpD3DHandle,
+            if (FAILED(IDirect3D9_CheckDeviceFormatConversion(
+                                           priv->d3d_handle,
                                            D3DADAPTER_DEFAULT,
                                            D3DDEVTYPE_HAL,
-                                           gDisplayFormatTable[i].FourCC,
-                                           gDesktopFmt)))
-            return 0;
-
-            gMovieSrcFmt = gDisplayFormatTable[i].FourCC;
-            mp_msg(MSGT_VO,MSGL_V,"<vo_direct3d>Accepted Colorspace %s\n",
-                   vo_format_name(gDisplayFormatTable[i].MPlayerFormat));
+                                           fmt_table[i].fourcc,
+                                           priv->desktop_fmt))) {
+                mp_msg(MSGT_VO,MSGL_V,
+                "<vo_direct3d>Rejected image format: %s\n",
+                vo_format_name(fmt_table[i].mplayer_fmt));
+                return 0;
+            }
+
+            priv->movie_src_fmt = fmt_table[i].fourcc;
+            mp_msg(MSGT_VO,MSGL_V,"<vo_direct3d>Accepted image format: %s\n",
+                   vo_format_name(fmt_table[i].mplayer_fmt));
             return (VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW
                     /*| VFCAP_OSD*/ | VFCAP_HWSCALE_UP | VFCAP_HWSCALE_DOWN);
 
@@ -438,55 +427,52 @@ static int query_format (uint32_t MovieFormat)
  *
  *  @return 0 on success, -1 on failure
  */
+
 static int preinit(const char *arg)
 {
-    D3DDISPLAYMODE DisplayMode;
+    D3DDISPLAYMODE disp_mode;
+
     /* Set to zero all global variables. */
-    gIsPaused = 0;
-    gIsD3DConfigFinished = 0;
-    gIsPanscan = 0;
-    gpD3DHandle = NULL;
-    gpD3DDevice = NULL;
-    gpD3DSurface = NULL;
-    gpD3DBackBuf = NULL;
+    priv = calloc(1, sizeof (struct global_priv));
+    if (!priv) {
+        mp_msg(MSGT_VO,MSGL_ERR,"<vo_direct3d>Not enough memory\r\n");
+        return -1;
+    }
 
     /* FIXME
        > Please use subopt-helper.h for this, see vo_gl.c:preinit for
        > an example of how to use it.
     */
 
-    gpD3DHandle = Direct3DCreate9 (D3D_SDK_VERSION);
-    if (!gpD3DHandle)
-    {
+    priv->d3d_handle = Direct3DCreate9(D3D_SDK_VERSION);
+    if (!priv->d3d_handle) {
         mp_msg(MSGT_VO,MSGL_ERR,"<vo_direct3d>Unable to initialize Direct3D\n");
         return -1;
     }
 
-    if (FAILED (IDirect3D9_GetAdapterDisplayMode (gpD3DHandle,
-                                                  D3DADAPTER_DEFAULT,
-                                                  &DisplayMode)))
-    {
+    if (FAILED(IDirect3D9_GetAdapterDisplayMode(priv->d3d_handle,
+                                                D3DADAPTER_DEFAULT,
+                                                &disp_mode))) {
         mp_msg(MSGT_VO,MSGL_ERR,"<vo_direct3d>Could not read display mode\n");
         return -1;
     }
 
-    /* Store in gDesktopFmt the user desktop's colorspace. Usually XRGB. */
-    gDesktopFmt = DisplayMode.Format;
+    /* Store in priv->desktop_fmt the user desktop's colorspace. Usually XRGB. */
+    priv->desktop_fmt = disp_mode.Format;
 
-    mp_msg(MSGT_VO,MSGL_V,"DisplayMode.Width %d, DisplayMode.Height %d\n",
-           DisplayMode.Width, DisplayMode.Height);
+    mp_msg(MSGT_VO,MSGL_V,"disp_mode.Width %d, disp_mode.Height %d\n",
+           disp_mode.Width, disp_mode.Height);
 
     /* w32_common framework call. Configures window on the screen, gets
      * fullscreen dimensions and does other useful stuff.
      */
-    if (!vo_w32_init())
-    {
+    if (!vo_w32_init()) {
         mp_msg(MSGT_VO,MSGL_V,"Unable to configure onscreen window\r\n");
         return -1;
     }
 
-    /* Allow the first call to D3DConfigure. */
-    gIsD3DConfigFinished = 1;
+    /* Allow the first call to reconfigure_d3d. */
+    priv->is_cfg_finished = 1;
 
     return 0;
 }
@@ -498,27 +484,26 @@ static int preinit(const char *arg)
  */
 static int control(uint32_t request, void *data, ...)
 {
-    switch (request)
-    {
+    switch (request) {
     case VOCTRL_QUERY_FORMAT:
-        return query_format (*(uint32_t*) data);
+        return query_format(*(uint32_t*) data);
     case VOCTRL_GET_IMAGE: /* Direct Rendering. Not implemented yet. */
         mp_msg(MSGT_VO,MSGL_V,
                "<vo_direct3d>Direct Rendering request. Not implemented yet\n");
         return VO_NOTIMPL;
     case VOCTRL_DRAW_IMAGE:
-        return D3DRenderFrame (data);
+        return render_d3d_frame(data);
     case VOCTRL_FULLSCREEN:
         vo_w32_fullscreen();
-        D3DConfigure();
+        reconfigure_d3d();
         return VO_TRUE;
     case VOCTRL_RESET:
         return VO_NOTIMPL;
     case VOCTRL_PAUSE:
-        gIsPaused = 1;
+        priv->is_paused = 1;
         return VO_TRUE;
     case VOCTRL_RESUME:
-        gIsPaused = 0;
+        priv->is_paused = 0;
         return VO_TRUE;
     case VOCTRL_GUISUPPORT:
         return VO_NOTIMPL;
@@ -531,14 +516,14 @@ static int control(uint32_t request, void *data, ...)
         return VO_TRUE;
     case VOCTRL_BORDER:
         vo_w32_border();
-        D3DConfigure();
+        reconfigure_d3d();
         return VO_TRUE;
     case VOCTRL_UPDATE_SCREENINFO:
         w32_update_xinerama_info();
         return VO_TRUE;
 /*
     case VOCTRL_SET_PANSCAN:
-        CalculatePanscanRect ();
+        calc_panscan_rect ();
         return VO_TRUE;
     case VOCTRL_GET_PANSCAN:
         return VO_TRUE;
@@ -562,27 +547,25 @@ static int config(uint32_t width, uint32_t height, uint32_t d_width,
                   uint32_t d_height, uint32_t options, char *title,
                   uint32_t format)
 {
-    gSrcWidth = width;
-    gSrcHeight = height;
+
+    priv->src_width = width;
+    priv->src_height = height;
 
     /* w32_common framework call. Creates window on the screen with
      * the given coordinates.
      */
-    if (!vo_w32_config(d_width, d_height, options))
-    {
+    if (!vo_w32_config(d_width, d_height, options)) {
         mp_msg(MSGT_VO,MSGL_V,"Unable to create onscreen window\r\n");
         return VO_ERROR;
     }
 
-    if (gIsD3DConfigFinished)
-    {
-        gIsD3DConfigFinished = 0;
-        if (!D3DConfigure ())
-        {
-            gIsD3DConfigFinished = 1;
+    if (priv->is_cfg_finished) {
+        priv->is_cfg_finished = 0;
+        if (!reconfigure_d3d()) {
+            priv->is_cfg_finished = 1;
             return VO_ERROR;
         }
-        gIsD3DConfigFinished = 1;
+        priv->is_cfg_finished = 1;
     }
     return 0; /* Success */
 }
@@ -593,18 +576,15 @@ static int config(uint32_t width, uint32_t height, uint32_t d_width,
  */
 static void flip_page(void)
 {
-    if (FAILED (IDirect3DDevice9_Present (gpD3DDevice, 0, 0, 0, 0)))
-    {
+    if (FAILED(IDirect3DDevice9_Present(priv->d3d_device, 0, 0, 0, 0))) {
         mp_msg(MSGT_VO,MSGL_V,
                "<vo_direct3d>Video adapter became uncooperative.\n");
         mp_msg(MSGT_VO,MSGL_ERR,"<vo_direct3d>Trying to reinitialize it...\n");
-        if (!D3DConfigure())
-        {
+        if (!reconfigure_d3d()) {
             mp_msg(MSGT_VO,MSGL_V,"<vo_direct3d>Reinitialization Failed.\n");
             return;
         }
-        if (FAILED (IDirect3DDevice9_Present (gpD3DDevice, 0, 0, 0, 0)))
-        {
+        if (FAILED(IDirect3DDevice9_Present(priv->d3d_device, 0, 0, 0, 0))) {
             mp_msg(MSGT_VO,MSGL_V,"<vo_direct3d>Reinitialization Failed.\n");
             return;
         }
@@ -612,7 +592,7 @@ static void flip_page(void)
             mp_msg(MSGT_VO,MSGL_V,"<vo_direct3d>Video adapter reinitialized.\n");
 
     }
-    /*IDirect3DDevice9_Clear (gpD3DDevice, 0, NULL, D3DCLEAR_TARGET, 0, 0, 0);*/
+    /*IDirect3DDevice9_Clear (priv->d3d_device, 0, NULL, D3DCLEAR_TARGET, 0, 0, 0);*/
 }
 
 /** @brief libvo Callback: Draw OSD/Subtitles,
@@ -630,8 +610,10 @@ static void uninit(void)
 {
     mp_msg(MSGT_VO,MSGL_V,"<vo_direct3d>Uninitialization\r\n");
 
-    D3DUninit();
+    uninit_d3d();
     vo_w32_uninit(); /* w32_common framework call */
+    free (priv);
+    priv = NULL;
 }
 
 /** @brief libvo Callback: Handles video window events.
@@ -646,9 +628,9 @@ static void check_events(void)
      */
     flags = vo_w32_check_events();
     if (flags & VO_EVENT_RESIZE)
-        D3DConfigure();
+        reconfigure_d3d();
 
-    if ((flags & VO_EVENT_EXPOSE) && gIsPaused)
+    if ((flags & VO_EVENT_EXPOSE) && priv->is_paused)
         flip_page();
 }
 
@@ -657,40 +639,38 @@ static void check_events(void)
  */
 static int draw_slice(uint8_t *src[], int stride[], int w,int h,int x,int y )
 {
-    D3DLOCKED_RECT  stLockedRect;   /**< Offscreen surface we lock in order
+    D3DLOCKED_RECT  locked_rect;   /**< Offscreen surface we lock in order
                                          to copy MPlayer's frame inside it.*/
     char *Src;      /**< Pointer to the source image */
     char *Dst;      /**< Pointer to the destination image */
     int  UVstride;  /**< Stride of the U/V planes */
 
-    if (FAILED (IDirect3DDevice9_BeginScene(gpD3DDevice)))
-    {
+    if (FAILED(IDirect3DDevice9_BeginScene(priv->d3d_device))) {
        mp_msg(MSGT_VO,MSGL_ERR,"<vo_direct3d>BeginScene failed\n");
        return VO_ERROR;
     }
 
-    if (FAILED (IDirect3DSurface9_LockRect(gpD3DSurface,
-                                           &stLockedRect, NULL, 0)))
-    {
+    if (FAILED(IDirect3DSurface9_LockRect(priv->d3d_surface,
+                                           &locked_rect, NULL, 0))) {
         mp_msg(MSGT_VO,MSGL_V,"<vo_direct3d>Surface lock failure\n");
         return VO_FALSE;
     }
 
-    UVstride = stLockedRect.Pitch / 2;
+    UVstride = locked_rect.Pitch / 2;
 
     /* Copy Y */
-    Dst = stLockedRect.pBits;
-    Dst = Dst + stLockedRect.Pitch * y + x;
+    Dst = locked_rect.pBits;
+    Dst = Dst + locked_rect.Pitch * y + x;
     Src=src[0];
-    memcpy_pic(Dst, Src, w, h, stLockedRect.Pitch, stride[0]);
+    memcpy_pic(Dst, Src, w, h, locked_rect.Pitch, stride[0]);
 
     w/=2;h/=2;x/=2;y/=2;
 
     /* Copy U */
-    Dst = stLockedRect.pBits;
-    Dst = Dst + stLockedRect.Pitch * gSrcHeight
+    Dst = locked_rect.pBits;
+    Dst = Dst + locked_rect.Pitch * priv->src_height
           + UVstride * y + x;
-    if (gMovieSrcFmt == MAKEFOURCC('Y','V','1','2'))
+    if (priv->movie_src_fmt == MAKEFOURCC('Y','V','1','2'))
         Src=src[2];
     else
         Src=src[1];
@@ -698,38 +678,35 @@ static int draw_slice(uint8_t *src[], int stride[], int w,int h,int x,int y )
     memcpy_pic(Dst, Src, w, h, UVstride, stride[1]);
 
     /* Copy V */
-    Dst = stLockedRect.pBits;
-    Dst = Dst + stLockedRect.Pitch * gSrcHeight
-          + UVstride * (gSrcHeight / 2) + UVstride * y + x;
-    if (gMovieSrcFmt == MAKEFOURCC('Y','V','1','2'))
+    Dst = locked_rect.pBits;
+    Dst = Dst + locked_rect.Pitch * priv->src_height
+          + UVstride * (priv->src_height / 2) + UVstride * y + x;
+    if (priv->movie_src_fmt == MAKEFOURCC('Y','V','1','2'))
         Src=src[1];
     else
         Src=src[2];
 
     memcpy_pic(Dst, Src, w, h, UVstride, stride[2]);
 
-    if (FAILED (IDirect3DSurface9_UnlockRect(gpD3DSurface)))
-    {
+    if (FAILED(IDirect3DSurface9_UnlockRect(priv->d3d_surface))) {
         mp_msg(MSGT_VO,MSGL_V,"<vo_direct3d>Surface unlock failure\n");
         return VO_ERROR;
     }
 
-    if (FAILED (IDirect3DDevice9_StretchRect (gpD3DDevice,
-                                              gpD3DSurface,
-                                              gIsPanscan ?
-                                              &gPanScanSrcRect : NULL,
-                                              gpD3DBackBuf,
-                                              vo_fs ?
-                                              &gFullScrMovieRect : NULL,
-                                              D3DTEXF_LINEAR)))
-    {
+    if (FAILED(IDirect3DDevice9_StretchRect(priv->d3d_device,
+                                            priv->d3d_surface,
+                                            priv->is_panscan ?
+                                            &priv->fs_panscan_rect : NULL,
+                                            priv->d3d_backbuf,
+                                            vo_fs ?
+                                            &priv->fs_movie_rect : NULL,
+                                            D3DTEXF_LINEAR))) {
         mp_msg(MSGT_VO,MSGL_V,
                "<vo_direct3d>Unable to copy the frame to the back buffer\n");
         return VO_ERROR;
     }
 
-    if (FAILED (IDirect3DDevice9_EndScene(gpD3DDevice)))
-    {
+    if (FAILED(IDirect3DDevice9_EndScene(priv->d3d_device))) {
        mp_msg(MSGT_VO,MSGL_ERR,"<vo_direct3d>EndScene failed\n");
        return VO_ERROR;
     }
@@ -745,8 +722,3 @@ static int draw_frame(uint8_t *src[])
     mp_msg(MSGT_VO,MSGL_V,"<vo_direct3d>draw_frame called\n");
     return VO_FALSE;
 }
-
-
-
-
-