1 files changed, 275 insertions, 95 deletions

diff --git a/src/gallium/state_trackers/wgl/shared/stw_framebuffer.c b/src/gallium/state_trackers/wgl/shared/stw_framebuffer.c
index 4348b8f326..78a2dbc4d7 100644
--- a/src/gallium/state_trackers/wgl/shared/stw_framebuffer.c
+++ b/src/gallium/state_trackers/wgl/shared/stw_framebuffer.c
@@ -45,11 +45,46 @@
 #include "stw_tls.h"
 
 
+static INLINE struct stw_framebuffer *
+stw_framebuffer_from_hwnd_locked(
+   HWND hwnd )
+{
+   struct stw_framebuffer *fb;
+
+   for (fb = stw_dev->fb_head; fb != NULL; fb = fb->next)
+      if (fb->hWnd == hwnd)
+         break;
+
+   return fb;
+}
+
+
+static INLINE void
+stw_framebuffer_destroy_locked(
+   struct stw_framebuffer *fb )
+{
+   struct stw_framebuffer **link;
+
+   link = &stw_dev->fb_head;
+   while (*link != fb)
+      link = &(*link)->next;
+   assert(*link);
+   *link = fb->next;
+   fb->next = NULL;
+
+   st_unreference_framebuffer(fb->stfb);
+   
+   pipe_mutex_destroy( fb->mutex );
+   
+   FREE( fb );
+}
+
+
 /**
  * @sa http://msdn.microsoft.com/en-us/library/ms644975(VS.85).aspx
  * @sa http://msdn.microsoft.com/en-us/library/ms644960(VS.85).aspx
  */
-static LRESULT CALLBACK
+LRESULT CALLBACK
 stw_call_window_proc(
    int nCode,
    WPARAM wParam,
@@ -69,126 +104,233 @@ stw_call_window_proc(
       struct stw_framebuffer *fb;
 
       pipe_mutex_lock( stw_dev->mutex );
-      for (fb = stw_dev->fb_head; fb != NULL; fb = fb->next)
-         if (fb->hWnd == pParams->hwnd)
-            break;
+      fb = stw_framebuffer_from_hwnd_locked( pParams->hwnd );
       pipe_mutex_unlock( stw_dev->mutex );
       
       if(fb) {
          unsigned width = LOWORD( pParams->lParam );
          unsigned height = HIWORD( pParams->lParam );
          
-         /* FIXME: The mesa statetracker makes the assumptions that only
-          * one context is using the framebuffer, and that that context is the 
-          * current one. However neither holds true, as WGL allows more than
-          * one context to be bound to the same drawable, and this function can 
-          * be called from any thread.
-          */
          pipe_mutex_lock( fb->mutex );
-         st_resize_framebuffer( fb->stfb, width, height );
+         fb->must_resize = TRUE;
+         fb->width = width;
+         fb->height = height;
          pipe_mutex_unlock( fb->mutex );
       }
    }
 
+   if (pParams->message == WM_DESTROY) {
+      struct stw_framebuffer *fb;
+
+      pipe_mutex_lock( stw_dev->mutex );
+      
+      fb = stw_framebuffer_from_hwnd_locked( pParams->hwnd );
+      if(fb)
+         stw_framebuffer_destroy_locked(fb);
+      
+      pipe_mutex_unlock( stw_dev->mutex );
+   }
+
    return CallNextHookEx(tls_data->hCallWndProcHook, nCode, wParam, lParam);
 }
 
 
-/* Create a new framebuffer object which will correspond to the given HDC.
+static void
+stw_framebuffer_get_size( struct stw_framebuffer *fb )
+{
+   unsigned width, height;
+   RECT rect;
+
+   assert(fb->hWnd);
+   
+   GetClientRect( fb->hWnd, &rect );
+   width = rect.right - rect.left;
+   height = rect.bottom - rect.top;
+
+   if(width < 1)
+      width = 1;
+   if(height < 1)
+      height = 1;
+
+   if(width != fb->width || height != fb->height) {
+      fb->must_resize = TRUE;
+      fb->width = width; 
+      fb->height = height; 
+   }
+}
+
+
+/**
+ * Create a new framebuffer object which will correspond to the given HDC.
  */
 struct stw_framebuffer *
-stw_framebuffer_create(
+stw_framebuffer_create_locked(
    HDC hdc,
-   GLvisual *visual,
-   const struct stw_pixelformat_info *pfi,
-   GLuint width,
-   GLuint height )
+   int iPixelFormat )
 {
-   enum pipe_format colorFormat, depthFormat, stencilFormat;
+   HWND hWnd;
    struct stw_framebuffer *fb;
+   const struct stw_pixelformat_info *pfi;
 
-   colorFormat = pfi->color_format;
+   /* We only support drawing to a window. */
+   hWnd = WindowFromDC( hdc );
+   if(!hWnd)
+      return NULL;
    
-   assert(pf_layout( pfi->depth_stencil_format ) == PIPE_FORMAT_LAYOUT_RGBAZS );
-
-   if(pf_get_component_bits( pfi->depth_stencil_format, PIPE_FORMAT_COMP_Z ))
-      depthFormat = pfi->depth_stencil_format;
-   else
-      depthFormat = PIPE_FORMAT_NONE;
-
-   if(pf_get_component_bits( pfi->depth_stencil_format, PIPE_FORMAT_COMP_S ))
-      stencilFormat = pfi->depth_stencil_format;
-   else
-      stencilFormat = PIPE_FORMAT_NONE;
-
    fb = CALLOC_STRUCT( stw_framebuffer );
    if (fb == NULL)
       return NULL;
 
    fb->hDC = hdc;
-   fb->hWnd = WindowFromDC( hdc );
+   fb->hWnd = hWnd;
+   fb->iPixelFormat = iPixelFormat;
 
-   pipe_mutex_init( fb->mutex );
+   fb->pfi = pfi = stw_pixelformat_get_info( iPixelFormat - 1 );
 
-   fb->stfb = st_create_framebuffer(
-      visual,
-      colorFormat,
-      depthFormat,
-      stencilFormat,
-      width,
-      height,
-      (void *) fb );
-   if(!fb->stfb) {
-      FREE(fb);
-      return NULL;
-   }
+   stw_pixelformat_visual(&fb->visual, pfi);
+   
+   stw_framebuffer_get_size(fb);
+
+   pipe_mutex_init( fb->mutex );
 
-   pipe_mutex_lock( stw_dev->mutex );
    fb->next = stw_dev->fb_head;
    stw_dev->fb_head = fb;
-   pipe_mutex_unlock( stw_dev->mutex );
 
    return fb;
 }
 
-void
-stw_framebuffer_destroy(
-   struct stw_framebuffer *fb )
+
+BOOL
+stw_framebuffer_allocate(
+   struct stw_framebuffer *fb)
 {
-   struct stw_framebuffer **link;
+   pipe_mutex_lock( fb->mutex );
 
-   pipe_mutex_lock( stw_dev->mutex );
+   if(!fb->stfb) {
+      const struct stw_pixelformat_info *pfi = fb->pfi;
+      enum pipe_format colorFormat, depthFormat, stencilFormat;
 
-   link = &stw_dev->fb_head;
-   while (link && *link != fb)
-      link = &(*link)->next;
-   assert(*link);
-   if (link)
-      *link = fb->next;
-   fb->next = NULL;
+      colorFormat = pfi->color_format;
+      
+      assert(pf_layout( pfi->depth_stencil_format ) == PIPE_FORMAT_LAYOUT_RGBAZS );
+   
+      if(pf_get_component_bits( pfi->depth_stencil_format, PIPE_FORMAT_COMP_Z ))
+         depthFormat = pfi->depth_stencil_format;
+      else
+         depthFormat = PIPE_FORMAT_NONE;
+   
+      if(pf_get_component_bits( pfi->depth_stencil_format, PIPE_FORMAT_COMP_S ))
+         stencilFormat = pfi->depth_stencil_format;
+      else
+         stencilFormat = PIPE_FORMAT_NONE;
+   
+      assert(fb->must_resize);
+      assert(fb->width);
+      assert(fb->height);
+
+      fb->stfb = st_create_framebuffer(
+         &fb->visual,
+         colorFormat,
+         depthFormat,
+         stencilFormat,
+         fb->width,
+         fb->height,
+         (void *) fb );
+      
+      // to notify the context
+      fb->must_resize = TRUE;
+   }
+   
+   pipe_mutex_unlock( fb->mutex );
 
-   pipe_mutex_unlock( stw_dev->mutex );
+   return fb->stfb ? TRUE : FALSE;
+}
 
-   st_unreference_framebuffer(fb->stfb);
+
+/**
+ * Update the framebuffer's size if necessary.
+ */
+void
+stw_framebuffer_update(
+   struct stw_framebuffer *fb)
+{
+   assert(fb->stfb);
+   assert(fb->height);
+   assert(fb->width);
    
-   pipe_mutex_destroy( fb->mutex );
+   /* XXX: It would be nice to avoid checking the size again -- in theory  
+    * stw_call_window_proc would have cought the resize and stored the right 
+    * size already, but unfortunately threads created before the DllMain is 
+    * called don't get a DLL_THREAD_ATTACH notification, and there is no way
+    * to know of their existing without using the not very portable PSAPI.
+    */
+   stw_framebuffer_get_size(fb);
    
-   FREE( fb );
+   if(fb->must_resize) {
+      st_resize_framebuffer(fb->stfb, fb->width, fb->height);
+      fb->must_resize = FALSE;
+   }
+}                      
+
+
+void
+stw_framebuffer_cleanup( void )
+{
+   struct stw_framebuffer *fb;
+   struct stw_framebuffer *next;
+
+   pipe_mutex_lock( stw_dev->mutex );
+
+   fb = stw_dev->fb_head;
+   while (fb) {
+      next = fb->next;
+      stw_framebuffer_destroy_locked(fb);
+      fb = next;
+   }
+   stw_dev->fb_head = NULL;
+   
+   pipe_mutex_unlock( stw_dev->mutex );
 }
 
+
 /**
  * Given an hdc, return the corresponding stw_framebuffer.
  */
 struct stw_framebuffer *
-stw_framebuffer_from_hdc(
+stw_framebuffer_from_hdc_locked(
    HDC hdc )
 {
+   HWND hwnd;
    struct stw_framebuffer *fb;
 
-   pipe_mutex_lock( stw_dev->mutex );
+   /* 
+    * Some applications create and use several HDCs for the same window, so 
+    * looking up the framebuffer by the HDC is not reliable. Use HWND whenever
+    * possible.
+    */ 
+   hwnd = WindowFromDC(hdc);
+   if(hwnd)
+      return stw_framebuffer_from_hwnd_locked(hwnd);
+   
    for (fb = stw_dev->fb_head; fb != NULL; fb = fb->next)
       if (fb->hDC == hdc)
          break;
+
+   return fb;
+}
+
+
+/**
+ * Given an hdc, return the corresponding stw_framebuffer.
+ */
+struct stw_framebuffer *
+stw_framebuffer_from_hdc(
+   HDC hdc )
+{
+   struct stw_framebuffer *fb;
+
+   pipe_mutex_lock( stw_dev->mutex );
+   fb = stw_framebuffer_from_hdc_locked(hdc);
    pipe_mutex_unlock( stw_dev->mutex );
 
    return fb;
@@ -196,6 +338,62 @@ stw_framebuffer_from_hdc(
 
 
 BOOL
+stw_pixelformat_set(
+   HDC hdc,
+   int iPixelFormat )
+{
+   uint count;
+   uint index;
+   struct stw_framebuffer *fb;
+
+   index = (uint) iPixelFormat - 1;
+   count = stw_pixelformat_get_extended_count();
+   if (index >= count)
+      return FALSE;
+
+   pipe_mutex_lock( stw_dev->mutex );
+   
+   fb = stw_framebuffer_from_hdc_locked(hdc);
+   if(fb) {
+      /* SetPixelFormat must be called only once */
+      pipe_mutex_unlock( stw_dev->mutex );
+      return FALSE;
+   }
+
+   fb = stw_framebuffer_create_locked(hdc, iPixelFormat);
+   if(!fb) {
+      pipe_mutex_unlock( stw_dev->mutex );
+      return FALSE;
+   }
+      
+   pipe_mutex_unlock( stw_dev->mutex );
+
+   /* Some applications mistakenly use the undocumented wglSetPixelFormat 
+    * function instead of SetPixelFormat, so we call SetPixelFormat here to 
+    * avoid opengl32.dll's wglCreateContext to fail */
+   if (GetPixelFormat(hdc) == 0) {
+        SetPixelFormat(hdc, iPixelFormat, NULL);
+   }
+   
+   return TRUE;
+}
+
+
+int
+stw_pixelformat_get(
+   HDC hdc )
+{
+   struct stw_framebuffer *fb;
+
+   fb = stw_framebuffer_from_hdc(hdc);
+   if(!fb)
+      return 0;
+   
+   return fb->iPixelFormat;
+}
+
+
+BOOL
 stw_swap_buffers(
    HDC hdc )
 {
@@ -207,6 +405,9 @@ stw_swap_buffers(
    if (fb == NULL)
       return FALSE;
 
+   if (!(fb->pfi->pfd.dwFlags & PFD_DOUBLEBUFFER))
+      return TRUE;
+
    pipe_mutex_lock( fb->mutex );
 
    /* If we're swapping the buffer associated with the current context
@@ -231,42 +432,21 @@ stw_swap_buffers(
 
    stw_dev->stw_winsys->flush_frontbuffer( screen, surface, hdc );
    
+   stw_framebuffer_update(fb);
+   
    pipe_mutex_unlock( fb->mutex );
    
    return TRUE;
 }
 
 
-boolean
-stw_framebuffer_init_thread(void)
+BOOL
+stw_swap_layer_buffers(
+   HDC hdc,
+   UINT fuPlanes )
 {
-   struct stw_tls_data *tls_data;
-   
-   tls_data = stw_tls_get_data();
-   if(!tls_data)
-      return FALSE;
-   
-   tls_data->hCallWndProcHook = SetWindowsHookEx(WH_CALLWNDPROC,
-                                                 stw_call_window_proc,
-                                                 NULL,
-                                                 GetCurrentThreadId());
-   if(tls_data->hCallWndProcHook == NULL)
-      return FALSE;
-   
-   return TRUE;
-}
+   if(fuPlanes & WGL_SWAP_MAIN_PLANE)
+      return stw_swap_buffers(hdc);
 
-void
-stw_framebuffer_cleanup_thread(void)
-{
-   struct stw_tls_data *tls_data;
-   
-   tls_data = stw_tls_get_data();
-   if(!tls_data)
-      return;
-   
-   if(tls_data->hCallWndProcHook) {
-      UnhookWindowsHookEx(tls_data->hCallWndProcHook);
-      tls_data->hCallWndProcHook = NULL;
-   }
+   return FALSE;
 }