[PATCH] winex11: Avoid double initialization of variables in OpenGL functions.

Stefan Dösinger stefandoesinger at gmail.com
Wed Nov 4 03:50:48 CST 2015


-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA256

Hi Alex,

Your diff appears to have a huge amount of context around the changes. Is that intentional?

Stefan

Am 2015-11-04 um 06:15 schrieb Alex Henrie:
> Cc: Vincent Povirk <vincent at codeweavers.com>
> 
> Signed-off-by: Alex Henrie <alexhenrie24 at gmail.com>
> ---
>  dlls/winex11.drv/opengl.c | 17 +++++++++--------
>  1 file changed, 9 insertions(+), 8 deletions(-)
> 
> diff --git a/dlls/winex11.drv/opengl.c b/dlls/winex11.drv/opengl.c
> index 7b8ba82..99befde 100644
> --- a/dlls/winex11.drv/opengl.c
> +++ b/dlls/winex11.drv/opengl.c
> @@ -947,124 +947,125 @@ static int ConvertAttribWGLtoGLX(const int* iWGLAttr, int* oGLXAttr, struct wgl_
>      case WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV:
>      case WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV:
>      case WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV:
>      case WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV:
>        pop = iWGLAttr[++cur];
>        /** cannot be converted, see direct handling on 
>         *   - wglGetPixelFormatAttribivARB
>         *  TODO: wglChoosePixelFormat
>         */
>        break ;
>      case WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT:
>        pop = iWGLAttr[++cur];
>        PUSH2(oGLXAttr, GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT, pop);
>        TRACE("pAttr[%d] = GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT: %x\n", cur, pop);
>        break ;
>  
>      case WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT:
>        pop = iWGLAttr[++cur];
>        PUSH2(oGLXAttr, GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT, pop);
>        TRACE("pAttr[%d] = GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT: %x\n", cur, pop);
>        break ;
>      default:
>        FIXME("unsupported %x WGL Attribute\n", iWGLAttr[cur]);
>        cur++;
>        break;
>      }
>      ++cur;
>    }
>  
>    /* By default glXChooseFBConfig defaults to GLX_WINDOW_BIT. wglChoosePixelFormatARB searches through
>     * all formats. Unless drawattrib is set to a non-zero value override it with GLX_DONT_CARE, so that
>     * pixmap and pbuffer formats appear as well. */
>    if (!drawattrib) drawattrib = GLX_DONT_CARE;
>    PUSH2(oGLXAttr, GLX_DRAWABLE_TYPE, drawattrib);
>    TRACE("pAttr[?] = GLX_DRAWABLE_TYPE: %#x\n", drawattrib);
>  
>    /* By default glXChooseFBConfig uses GLX_RGBA_BIT as the default value. Since wglChoosePixelFormatARB
>     * searches in all formats we have to do the same. For this reason we set GLX_RENDER_TYPE to
>     * GLX_DONT_CARE unless it is overridden. */
>    PUSH2(oGLXAttr, GLX_RENDER_TYPE, pixelattrib);
>    TRACE("pAttr[?] = GLX_RENDER_TYPE: %#x\n", pixelattrib);
>  
>    /* Set GLX_FLOAT_COMPONENTS_NV all the time */
>    if (has_extension(WineGLInfo.glxExtensions, "GLX_NV_float_buffer")) {
>      PUSH2(oGLXAttr, GLX_FLOAT_COMPONENTS_NV, nvfloatattrib);
>      TRACE("pAttr[?] = GLX_FLOAT_COMPONENTS_NV: %#x\n", nvfloatattrib);
>    }
>  
>    return nAttribs;
>  }
>  
>  static int get_render_type_from_fbconfig(Display *display, GLXFBConfig fbconfig)
>  {
> -    int render_type=0, render_type_bit;
> +    int render_type, render_type_bit;
>      pglXGetFBConfigAttrib(display, fbconfig, GLX_RENDER_TYPE, &render_type_bit);
>      switch(render_type_bit)
>      {
>          case GLX_RGBA_BIT:
>              render_type = GLX_RGBA_TYPE;
>              break;
>          case GLX_COLOR_INDEX_BIT:
>              render_type = GLX_COLOR_INDEX_TYPE;
>              break;
>          case GLX_RGBA_FLOAT_BIT:
>              render_type = GLX_RGBA_FLOAT_TYPE;
>              break;
>          case GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT:
>              render_type = GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT;
>              break;
>          default:
>              ERR("Unknown render_type: %x\n", render_type_bit);
> +            render_type = 0;
>      }
>      return render_type;
>  }
>  
>  /* Check whether a fbconfig is suitable for Windows-style bitmap rendering */
>  static BOOL check_fbconfig_bitmap_capability(Display *display, GLXFBConfig fbconfig)
>  {
>      int dbuf, value;
>      pglXGetFBConfigAttrib(display, fbconfig, GLX_DOUBLEBUFFER, &dbuf);
>      pglXGetFBConfigAttrib(gdi_display, fbconfig, GLX_DRAWABLE_TYPE, &value);
>  
>      /* Windows only supports bitmap rendering on single buffered formats, further the fbconfig needs to have
>       * the GLX_PIXMAP_BIT set. */
>      return !dbuf && (value & GLX_PIXMAP_BIT);
>  }
>  
>  static void init_pixel_formats( Display *display )
>  {
>      struct wgl_pixel_format *list;
>      int size = 0, onscreen_size = 0;
>      int fmt_id, nCfgs, i, run, bmp_formats;
>      GLXFBConfig* cfgs;
>      XVisualInfo *visinfo;
>  
>      cfgs = pglXGetFBConfigs(display, DefaultScreen(display), &nCfgs);
>      if (NULL == cfgs || 0 == nCfgs) {
>          if(cfgs != NULL) XFree(cfgs);
>          ERR("glXChooseFBConfig returns NULL\n");
>          return;
>      }
>  
>      /* Bitmap rendering on Windows implies the use of the Microsoft GDI software renderer.
>       * Further most GLX drivers only offer pixmap rendering using indirect rendering (except for modern drivers which support 'AIGLX' / composite).
>       * Indirect rendering can indicate software rendering (on Nvidia it is hw accelerated)
>       * Since bitmap rendering implies the use of software rendering we can safely use indirect rendering for bitmaps.
>       *
>       * Below we count the number of formats which are suitable for bitmap rendering. Windows restricts bitmap rendering to single buffered formats.
>       */
>      for(i=0, bmp_formats=0; i<nCfgs; i++)
>      {
>          if(check_fbconfig_bitmap_capability(display, cfgs[i]))
>              bmp_formats++;
>      }
>      TRACE("Found %d bitmap capable fbconfigs\n", bmp_formats);
>  
>      list = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (nCfgs + bmp_formats) * sizeof(*list));
>  
>      /* Fill the pixel format list. Put onscreen formats at the top and offscreen ones at the bottom.
>       * Do this as GLX doesn't guarantee that the list is sorted */
>      for(run=0; run < 2; run++)
>      {
>          for(i=0; i<nCfgs; i++) {
>              pglXGetFBConfigAttrib(display, cfgs[i], GLX_FBCONFIG_ID, &fmt_id);
> @@ -1737,107 +1738,107 @@ static int glxdrv_wglDescribePixelFormat( HDC hdc, int iPixelFormat,
>    if (TRACE_ON(wgl)) {
>      dump_PIXELFORMATDESCRIPTOR(ppfd);
>    }
>  
>    return nb_onscreen_formats;
>  }
>  
>  /***********************************************************************
>   *		glxdrv_wglGetPixelFormat
>   */
>  static int glxdrv_wglGetPixelFormat( HDC hdc )
>  {
>      struct gl_drawable *gl;
>      int ret = 0;
>  
>      if ((gl = get_gl_drawable( WindowFromDC( hdc ), hdc )))
>      {
>          ret = pixel_format_index( gl->format );
>          /* Offscreen formats can't be used with traditional WGL calls.
>           * As has been verified on Windows GetPixelFormat doesn't fail but returns iPixelFormat=1. */
>          if (!is_onscreen_pixel_format( ret )) ret = 1;
>          release_gl_drawable( gl );
>      }
>      TRACE( "%p -> %d\n", hdc, ret );
>      return ret;
>  }
>  
>  /***********************************************************************
>   *		glxdrv_wglSetPixelFormat
>   */
>  static BOOL glxdrv_wglSetPixelFormat( HDC hdc, int iPixelFormat, const PIXELFORMATDESCRIPTOR *ppfd )
>  {
>      return set_pixel_format(hdc, iPixelFormat, FALSE);
>  }
>  
>  /***********************************************************************
>   *		glxdrv_wglCopyContext
>   */
>  static BOOL glxdrv_wglCopyContext(struct wgl_context *src, struct wgl_context *dst, UINT mask)
>  {
>      TRACE("%p -> %p mask %#x\n", src, dst, mask);
>  
>      pglXCopyContext(gdi_display, src->ctx, dst->ctx, mask);
>  
>      /* As opposed to wglCopyContext, glXCopyContext doesn't return anything, so hopefully we passed */
>      return TRUE;
>  }
>  
>  /***********************************************************************
>   *		glxdrv_wglCreateContext
>   */
>  static struct wgl_context *glxdrv_wglCreateContext( HDC hdc )
>  {
> -    struct wgl_context *ret = NULL;
> +    struct wgl_context *ret;
>      struct gl_drawable *gl;
>  
>      if (!(gl = get_gl_drawable( WindowFromDC( hdc ), hdc )))
>      {
>          SetLastError( ERROR_INVALID_PIXEL_FORMAT );
>          return NULL;
>      }
>  
>      if ((ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ret))))
>      {
>          ret->hdc = hdc;
>          ret->fmt = gl->format;
>          ret->vis = pglXGetVisualFromFBConfig(gdi_display, gl->format->fbconfig);
>          ret->ctx = create_glxcontext(gdi_display, ret, NULL);
>          list_add_head( &context_list, &ret->entry );
>      }
>      release_gl_drawable( gl );
>      TRACE( "%p -> %p\n", hdc, ret );
>      return ret;
>  }
>  
>  /***********************************************************************
>   *		glxdrv_wglDeleteContext
>   */
>  static void glxdrv_wglDeleteContext(struct wgl_context *ctx)
>  {
>      TRACE("(%p)\n", ctx);
>  
>      EnterCriticalSection( &context_section );
>      list_remove( &ctx->entry );
>      LeaveCriticalSection( &context_section );
>  
>      if (ctx->ctx) pglXDestroyContext( gdi_display, ctx->ctx );
>      if (ctx->vis) XFree( ctx->vis );
>      HeapFree( GetProcessHeap(), 0, ctx );
>  }
>  
>  /***********************************************************************
>   *		glxdrv_wglGetProcAddress
>   */
>  static PROC glxdrv_wglGetProcAddress(LPCSTR lpszProc)
>  {
>      if (!strncmp(lpszProc, "wgl", 3)) return NULL;
>      return pglXGetProcAddressARB((const GLubyte*)lpszProc);
>  }
>  
>  /***********************************************************************
>   *		glxdrv_wglMakeCurrent
>   */
>  static BOOL glxdrv_wglMakeCurrent(HDC hdc, struct wgl_context *ctx)
>  {
>      BOOL ret = FALSE;
>      struct gl_drawable *gl;
> @@ -1987,205 +1988,205 @@ static void wglFinish(void)
>      {
>          switch (gl->type)
>          {
>          case DC_GL_PIXMAP_WIN: escape.gl_drawable = gl->pixmap; break;
>          case DC_GL_CHILD_WIN:  escape.gl_drawable = gl->drawable; break;
>          default: break;
>          }
>          sync_context(ctx);
>          release_gl_drawable( gl );
>      }
>  
>      pglFinish();
>      if (escape.gl_drawable) ExtEscape( ctx->hdc, X11DRV_ESCAPE, sizeof(escape), (LPSTR)&escape, 0, NULL );
>  }
>  
>  static void wglFlush(void)
>  {
>      struct x11drv_escape_flush_gl_drawable escape;
>      struct gl_drawable *gl;
>      struct wgl_context *ctx = NtCurrentTeb()->glContext;
>  
>      escape.code = X11DRV_FLUSH_GL_DRAWABLE;
>      escape.gl_drawable = 0;
>  
>      if ((gl = get_gl_drawable( WindowFromDC( ctx->hdc ), 0 )))
>      {
>          switch (gl->type)
>          {
>          case DC_GL_PIXMAP_WIN: escape.gl_drawable = gl->pixmap; break;
>          case DC_GL_CHILD_WIN:  escape.gl_drawable = gl->drawable; break;
>          default: break;
>          }
>          sync_context(ctx);
>          release_gl_drawable( gl );
>      }
>  
>      pglFlush();
>      if (escape.gl_drawable) ExtEscape( ctx->hdc, X11DRV_ESCAPE, sizeof(escape), (LPSTR)&escape, 0, NULL );
>  }
>  
>  static const GLubyte *wglGetString(GLenum name)
>  {
>      if (name == GL_EXTENSIONS && WineGLInfo.glExtensions)
>          return (const GLubyte *)WineGLInfo.glExtensions;
>      return pglGetString(name);
>  }
>  
>  /***********************************************************************
>   *		X11DRV_wglCreateContextAttribsARB
>   */
>  static struct wgl_context *X11DRV_wglCreateContextAttribsARB( HDC hdc, struct wgl_context *hShareContext,
>                                                                const int* attribList )
>  {
> -    struct wgl_context *ret = NULL;
> +    struct wgl_context *ret;
>      struct gl_drawable *gl;
>      int err = 0;
>  
>      TRACE("(%p %p %p)\n", hdc, hShareContext, attribList);
>  
>      if (!(gl = get_gl_drawable( WindowFromDC( hdc ), hdc )))
>      {
>          SetLastError( ERROR_INVALID_PIXEL_FORMAT );
>          return NULL;
>      }
>  
>      if ((ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ret))))
>      {
>          ret->hdc = hdc;
>          ret->fmt = gl->format;
>          ret->vis = NULL; /* glXCreateContextAttribsARB requires a fbconfig instead of a visual */
>          ret->gl3_context = TRUE;
>          if (attribList)
>          {
>              int *pContextAttribList = &ret->attribList[0];
>              /* attribList consists of pairs {token, value] terminated with 0 */
>              while(attribList[0] != 0)
>              {
>                  TRACE("%#x %#x\n", attribList[0], attribList[1]);
>                  switch(attribList[0])
>                  {
>                  case WGL_CONTEXT_MAJOR_VERSION_ARB:
>                      pContextAttribList[0] = GLX_CONTEXT_MAJOR_VERSION_ARB;
>                      pContextAttribList[1] = attribList[1];
>                      pContextAttribList += 2;
>                      ret->numAttribs++;
>                      break;
>                  case WGL_CONTEXT_MINOR_VERSION_ARB:
>                      pContextAttribList[0] = GLX_CONTEXT_MINOR_VERSION_ARB;
>                      pContextAttribList[1] = attribList[1];
>                      pContextAttribList += 2;
>                      ret->numAttribs++;
>                      break;
>                  case WGL_CONTEXT_LAYER_PLANE_ARB:
>                      break;
>                  case WGL_CONTEXT_FLAGS_ARB:
>                      pContextAttribList[0] = GLX_CONTEXT_FLAGS_ARB;
>                      pContextAttribList[1] = attribList[1];
>                      pContextAttribList += 2;
>                      ret->numAttribs++;
>                      break;
>                  case WGL_CONTEXT_PROFILE_MASK_ARB:
>                      pContextAttribList[0] = GLX_CONTEXT_PROFILE_MASK_ARB;
>                      pContextAttribList[1] = attribList[1];
>                      pContextAttribList += 2;
>                      ret->numAttribs++;
>                      break;
>                  default:
>                      ERR("Unhandled attribList pair: %#x %#x\n", attribList[0], attribList[1]);
>                  }
>                  attribList += 2;
>              }
>          }
>  
>          X11DRV_expect_error(gdi_display, GLXErrorHandler, NULL);
>          ret->ctx = create_glxcontext(gdi_display, ret, hShareContext ? hShareContext->ctx : NULL);
>          XSync(gdi_display, False);
>          if ((err = X11DRV_check_error()) || !ret->ctx)
>          {
>              /* In the future we should convert the GLX error to a win32 one here if needed */
>              ERR("Context creation failed (error %x)\n", err);
>              HeapFree( GetProcessHeap(), 0, ret );
>              ret = NULL;
>          }
>          else list_add_head( &context_list, &ret->entry );
>      }
>  
>      release_gl_drawable( gl );
>      TRACE( "%p -> %p\n", hdc, ret );
>      return ret;
>  }
>  
>  /**
>   * X11DRV_wglGetExtensionsStringARB
>   *
>   * WGL_ARB_extensions_string: wglGetExtensionsStringARB
>   */
>  static const char *X11DRV_wglGetExtensionsStringARB(HDC hdc)
>  {
>      TRACE("() returning \"%s\"\n", WineGLInfo.wglExtensions);
>      return WineGLInfo.wglExtensions;
>  }
>  
>  /**
>   * X11DRV_wglCreatePbufferARB
>   *
>   * WGL_ARB_pbuffer: wglCreatePbufferARB
>   */
>  static struct wgl_pbuffer *X11DRV_wglCreatePbufferARB( HDC hdc, int iPixelFormat, int iWidth, int iHeight,
>                                                         const int *piAttribList )
>  {
> -    struct wgl_pbuffer* object = NULL;
> -    const struct wgl_pixel_format *fmt = NULL;
> +    struct wgl_pbuffer* object;
> +    const struct wgl_pixel_format *fmt;
>      int attribs[256];
>      int nAttribs = 0;
>  
>      TRACE("(%p, %d, %d, %d, %p)\n", hdc, iPixelFormat, iWidth, iHeight, piAttribList);
>  
>      /* Convert the WGL pixelformat to a GLX format, if it fails then the format is invalid */
>      fmt = get_pixel_format(gdi_display, iPixelFormat, TRUE /* Offscreen */);
>      if(!fmt) {
>          ERR("(%p): invalid pixel format %d\n", hdc, iPixelFormat);
>          SetLastError(ERROR_INVALID_PIXEL_FORMAT);
>          return NULL;
>      }
>  
>      object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
>      if (NULL == object) {
>          SetLastError(ERROR_NO_SYSTEM_RESOURCES);
>          return NULL;
>      }
>      object->width = iWidth;
>      object->height = iHeight;
>      object->fmt = fmt;
>  
>      PUSH2(attribs, GLX_PBUFFER_WIDTH,  iWidth);
>      PUSH2(attribs, GLX_PBUFFER_HEIGHT, iHeight); 
>      while (piAttribList && 0 != *piAttribList) {
>          int attr_v;
>          switch (*piAttribList) {
>              case WGL_PBUFFER_LARGEST_ARB: {
>                  ++piAttribList;
>                  attr_v = *piAttribList;
>                  TRACE("WGL_LARGEST_PBUFFER_ARB = %d\n", attr_v);
>                  PUSH2(attribs, GLX_LARGEST_PBUFFER, attr_v);
>                  break;
>              }
>  
>              case WGL_TEXTURE_FORMAT_ARB: {
>                  ++piAttribList;
>                  attr_v = *piAttribList;
>                  TRACE("WGL_render_texture Attribute: WGL_TEXTURE_FORMAT_ARB as %x\n", attr_v);
>                  if (WGL_NO_TEXTURE_ARB == attr_v) {
>                      object->use_render_texture = 0;
>                  } else {
>                      if (!use_render_texture_emulation) {
>                          SetLastError(ERROR_INVALID_DATA);
>                          goto create_failed;
>                      }
>                      switch (attr_v) {
>                          case WGL_TEXTURE_RGB_ARB:
>                              object->use_render_texture = GL_RGB;
>                              object->texture_bpp = 3;
>                              object->texture_format = GL_RGB;
>                              object->texture_type = GL_UNSIGNED_BYTE;
>                              break;
> @@ -2457,213 +2458,213 @@ static BOOL X11DRV_wglQueryPbufferARB( struct wgl_pbuffer *object, int iAttribut
>   * WGL_ARB_pbuffer: wglReleasePbufferDCARB
>   */
>  static int X11DRV_wglReleasePbufferDCARB( struct wgl_pbuffer *object, HDC hdc )
>  {
>      struct gl_drawable *gl;
>  
>      TRACE("(%p, %p)\n", object, hdc);
>  
>      EnterCriticalSection( &context_section );
>  
>      if (!XFindContext( gdi_display, (XID)hdc, gl_pbuffer_context, (char **)&gl ))
>      {
>          XDeleteContext( gdi_display, (XID)hdc, gl_pbuffer_context );
>          free_gl_drawable( gl );
>      }
>      else hdc = 0;
>  
>      LeaveCriticalSection( &context_section );
>  
>      return hdc && DeleteDC(hdc);
>  }
>  
>  /**
>   * X11DRV_wglSetPbufferAttribARB
>   *
>   * WGL_ARB_pbuffer: wglSetPbufferAttribARB
>   */
>  static BOOL X11DRV_wglSetPbufferAttribARB( struct wgl_pbuffer *object, const int *piAttribList )
>  {
>      GLboolean ret = GL_FALSE;
>  
>      WARN("(%p, %p): alpha-testing, report any problem\n", object, piAttribList);
>  
>      if (!object->use_render_texture) {
>          SetLastError(ERROR_INVALID_HANDLE);
>          return GL_FALSE;
>      }
>      if (use_render_texture_emulation) {
>          return GL_TRUE;
>      }
>      return ret;
>  }
>  
>  /**
>   * X11DRV_wglChoosePixelFormatARB
>   *
>   * WGL_ARB_pixel_format: wglChoosePixelFormatARB
>   */
>  static BOOL X11DRV_wglChoosePixelFormatARB( HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList,
>                                              UINT nMaxFormats, int *piFormats, UINT *nNumFormats )
>  {
>      int attribs[256];
>      int nAttribs = 0;
> -    GLXFBConfig* cfgs = NULL;
> +    GLXFBConfig* cfgs;
>      int nCfgs = 0;
>      int it;
>      int fmt_id;
>      int start, end;
>      UINT pfmt_it = 0;
>      int run;
>      int i;
>      DWORD dwFlags = 0;
>  
>      TRACE("(%p, %p, %p, %d, %p, %p): hackish\n", hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
>      if (NULL != pfAttribFList) {
>          FIXME("unused pfAttribFList\n");
>      }
>  
>      nAttribs = ConvertAttribWGLtoGLX(piAttribIList, attribs, NULL);
>      if (-1 == nAttribs) {
>          WARN("Cannot convert WGL to GLX attributes\n");
>          return GL_FALSE;
>      }
>      PUSH1(attribs, None);
>  
>      /* There is no 1:1 mapping between GLX and WGL formats because we duplicate some GLX formats for bitmap rendering (see get_formats).
>       * Flags like PFD_SUPPORT_GDI, PFD_DRAW_TO_BITMAP and others are a property of the pixel format. We don't query these attributes
>       * using glXChooseFBConfig but we filter the result of glXChooseFBConfig later on.
>       */
>      for(i=0; piAttribIList[i] != 0; i+=2)
>      {
>          switch(piAttribIList[i])
>          {
>              case WGL_DRAW_TO_BITMAP_ARB:
>                  if(piAttribIList[i+1])
>                      dwFlags |= PFD_DRAW_TO_BITMAP;
>                  break;
>              case WGL_ACCELERATION_ARB:
>                  switch(piAttribIList[i+1])
>                  {
>                      case WGL_NO_ACCELERATION_ARB:
>                          dwFlags |= PFD_GENERIC_FORMAT;
>                          break;
>                      case WGL_GENERIC_ACCELERATION_ARB:
>                          dwFlags |= PFD_GENERIC_ACCELERATED;
>                          break;
>                      case WGL_FULL_ACCELERATION_ARB:
>                          /* Nothing to do */
>                          break;
>                  }
>                  break;
>              case WGL_SUPPORT_GDI_ARB:
>                  if(piAttribIList[i+1])
>                      dwFlags |= PFD_SUPPORT_GDI;
>                  break;
>          }
>      }
>  
>      /* Search for FB configurations matching the requirements in attribs */
>      cfgs = pglXChooseFBConfig(gdi_display, DefaultScreen(gdi_display), attribs, &nCfgs);
>      if (NULL == cfgs) {
>          WARN("Compatible Pixel Format not found\n");
>          return GL_FALSE;
>      }
>  
>      /* Loop through all matching formats and check if they are suitable.
>       * Note that this function should at max return nMaxFormats different formats */
>      for(run=0; run < 2; run++)
>      {
>          for (it = 0; it < nCfgs && pfmt_it < nMaxFormats; ++it)
>          {
>              if (pglXGetFBConfigAttrib(gdi_display, cfgs[it], GLX_FBCONFIG_ID, &fmt_id))
>              {
>                  ERR("Failed to retrieve FBCONFIG_ID from GLXFBConfig, expect problems.\n");
>                  continue;
>              }
>  
>              /* During the first run we only want onscreen formats and during the second only offscreen */
>              start = run == 1 ? nb_onscreen_formats : 0;
>              end = run == 1 ? nb_pixel_formats : nb_onscreen_formats;
>  
>              for (i = start; i < end; i++)
>              {
>                  if (pixel_formats[i].fmt_id == fmt_id && (pixel_formats[i].dwFlags & dwFlags) == dwFlags)
>                  {
>                      piFormats[pfmt_it++] = i + 1;
>                      TRACE("at %d/%d found FBCONFIG_ID 0x%x (%d)\n",
>                            it + 1, nCfgs, fmt_id, i + 1);
>                      break;
>                  }
>              }
>          }
>      }
>  
>      *nNumFormats = pfmt_it;
>      /** free list */
>      XFree(cfgs);
>      return GL_TRUE;
>  }
>  
>  /**
>   * X11DRV_wglGetPixelFormatAttribivARB
>   *
>   * WGL_ARB_pixel_format: wglGetPixelFormatAttribivARB
>   */
>  static BOOL X11DRV_wglGetPixelFormatAttribivARB( HDC hdc, int iPixelFormat, int iLayerPlane,
>                                                   UINT nAttributes, const int *piAttributes, int *piValues )
>  {
>      UINT i;
> -    const struct wgl_pixel_format *fmt = NULL;
> +    const struct wgl_pixel_format *fmt;
>      int hTest;
>      int tmp;
>      int curGLXAttr = 0;
>  
>      TRACE("(%p, %d, %d, %d, %p, %p)\n", hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
>  
>      if (0 < iLayerPlane) {
>          FIXME("unsupported iLayerPlane(%d) > 0, returns FALSE\n", iLayerPlane);
>          return GL_FALSE;
>      }
>  
>      /* Convert the WGL pixelformat to a GLX one, if this fails then most likely the iPixelFormat isn't supported.
>      * We don't have to fail yet as a program can specify an invalid iPixelFormat (lets say 0) if it wants to query
>      * the number of supported WGL formats. Whether the iPixelFormat is valid is handled in the for-loop below. */
>      fmt = get_pixel_format(gdi_display, iPixelFormat, TRUE /* Offscreen */);
>      if(!fmt) {
>          WARN("Unable to convert iPixelFormat %d to a GLX one!\n", iPixelFormat);
>      }
>  
>      for (i = 0; i < nAttributes; ++i) {
>          const int curWGLAttr = piAttributes[i];
>          TRACE("pAttr[%d] = %x\n", i, curWGLAttr);
>  
>          switch (curWGLAttr) {
>              case WGL_NUMBER_PIXEL_FORMATS_ARB:
>                  piValues[i] = nb_pixel_formats;
>                  continue;
>  
>              case WGL_SUPPORT_OPENGL_ARB:
>                  piValues[i] = GL_TRUE; 
>                  continue;
>  
>              case WGL_ACCELERATION_ARB:
>                  curGLXAttr = GLX_CONFIG_CAVEAT;
>                  if (!fmt) goto pix_error;
>                  if(fmt->dwFlags & PFD_GENERIC_FORMAT)
>                      piValues[i] = WGL_NO_ACCELERATION_ARB;
>                  else if(fmt->dwFlags & PFD_GENERIC_ACCELERATED)
>                      piValues[i] = WGL_GENERIC_ACCELERATION_ARB;
>                  else
>                      piValues[i] = WGL_FULL_ACCELERATION_ARB;
>                  continue;
>  
>              case WGL_TRANSPARENT_ARB:
>                  curGLXAttr = GLX_TRANSPARENT_TYPE;
>                  if (!fmt) goto pix_error;
>                  hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, curGLXAttr, &tmp);
>                  if (hTest) goto get_error;
>                  piValues[i] = GL_FALSE;
>                  if (GLX_NONE != tmp) piValues[i] = GL_TRUE;
>                  continue;
>  
>              case WGL_PIXEL_TYPE_ARB:
> @@ -2979,107 +2980,107 @@ static BOOL X11DRV_wglReleaseTexImageARB( struct wgl_pbuffer *object, int iBuffe
>          return GL_TRUE;
>      }
>      return ret;
>  }
>  
>  /**
>   * X11DRV_wglGetExtensionsStringEXT
>   *
>   * WGL_EXT_extensions_string: wglGetExtensionsStringEXT
>   */
>  static const char *X11DRV_wglGetExtensionsStringEXT(void)
>  {
>      TRACE("() returning \"%s\"\n", WineGLInfo.wglExtensions);
>      return WineGLInfo.wglExtensions;
>  }
>  
>  /**
>   * X11DRV_wglGetSwapIntervalEXT
>   *
>   * WGL_EXT_swap_control: wglGetSwapIntervalEXT
>   */
>  static int X11DRV_wglGetSwapIntervalEXT(void)
>  {
>      struct wgl_context *ctx = NtCurrentTeb()->glContext;
>      struct gl_drawable *gl;
>      int swap_interval;
>  
>      TRACE("()\n");
>  
>      if (!(gl = get_gl_drawable( WindowFromDC( ctx->hdc ), ctx->hdc )))
>      {
>          /* This can't happen because a current WGL context is required to get
>           * here. Likely the application is buggy.
>           */
>          WARN("No GL drawable found, returning swap interval 0\n");
>          return 0;
>      }
>  
>      swap_interval = gl->swap_interval;
>      release_gl_drawable(gl);
>  
>      return swap_interval;
>  }
>  
>  /**
>   * X11DRV_wglSwapIntervalEXT
>   *
>   * WGL_EXT_swap_control: wglSwapIntervalEXT
>   */
>  static BOOL X11DRV_wglSwapIntervalEXT(int interval)
>  {
>      struct wgl_context *ctx = NtCurrentTeb()->glContext;
>      struct gl_drawable *gl;
> -    BOOL ret = TRUE;
> +    BOOL ret;
>  
>      TRACE("(%d)\n", interval);
>  
>      /* Without WGL/GLX_EXT_swap_control_tear a negative interval
>       * is invalid.
>       */
>      if (interval < 0 && !has_swap_control_tear)
>      {
>          SetLastError(ERROR_INVALID_DATA);
>          return FALSE;
>      }
>  
>      if (!(gl = get_gl_drawable( WindowFromDC( ctx->hdc ), ctx->hdc )))
>      {
>          SetLastError(ERROR_DC_NOT_FOUND);
>          return FALSE;
>      }
>  
>      ret = set_swap_interval(gl->drawable, interval);
>      gl->refresh_swap_interval = FALSE;
>      if (ret)
>          gl->swap_interval = interval;
>      else
>          SetLastError(ERROR_DC_NOT_FOUND);
>  
>      release_gl_drawable(gl);
>  
>      return ret;
>  }
>  
>  /**
>   * X11DRV_wglSetPixelFormatWINE
>   *
>   * WGL_WINE_pixel_format_passthrough: wglSetPixelFormatWINE
>   * This is a WINE-specific wglSetPixelFormat which can set the pixel format multiple times.
>   */
>  static BOOL X11DRV_wglSetPixelFormatWINE(HDC hdc, int format)
>  {
>      return set_pixel_format(hdc, format, TRUE);
>  }
>  
>  /**
>   * glxRequireVersion (internal)
>   *
>   * Check if the supported GLX version matches requiredVersion.
>   */
>  static BOOL glxRequireVersion(int requiredVersion)
>  {
>      /* Both requiredVersion and glXVersion[1] contains the minor GLX version */
>      if(requiredVersion <= WineGLInfo.glxVersion[1])
>          return TRUE;
>  
>      return FALSE;
> 

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2

iQIcBAEBCAAGBQJWOdT4AAoJEN0/YqbEcdMwrKMP/3A3YDS+Z8D9DryqO0M+uGFb
dpXvi5pCXIir7VK12bO57tj3NTZ0i9R+COfmwFTb883e6MdcIDsMd3+w8o0A/vj0
7U5yZuxE0gWkFL2veP2L7q+nx7NInYEaWuKmm/Ilu0vDQV0Azr3oyETyih2VZdxE
WqXvh/V90JeFBXf6QtyrPRczXdjcP5BMlI3LW7xLTg4lrxGv3E6r/2wOFl87Ezo1
zHQ8ZF+BWtK2m5vz6OZBoyvPD0XMB+3NJaxfqZ5JI37bJfnO8nu5WyyZEx/6ilxN
TuFacVAewVth53Uo9svNOodvZ3hsIP1JILQ4KAOBUbo6/31GIufxGjHdXfzEpRmX
Xf3+rBdVPtZO/fwbIJnoMMBZbUB3ysOf+WSsH341fa4XmUgppG0enyLve19HcnUV
ZV1yyX+veAdjEjF/bu72XMowPH9yQNR72buwqdxfbVOckeUuIOuyeRjT+VloGQCv
Y3FrstuvoCEJCedSGm96zSHhN2sRNeHvCxoRECuivdoo2e8iCXhC+otkKyoH4zN1
cGXVraN+oabyiwe+K2ItWGeiNKp0Es+eQtckYbna7SmbpslkFjhWjju7NaDbJJgS
wZq+Na9hYC/zN5Ae921DSegHEuTtjbFBA4JmD54oVYGAK0cA5V88qsEFbkBgH+fp
WfiGk1hZGePFQvXm7kiN
=H5zR
-----END PGP SIGNATURE-----



More information about the wine-devel mailing list