X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fstate_tracker%2Fst_manager.c;h=7abd128e719c0eee847bddd9ae2c959294217de2;hb=0fc21ecfc0891d239f20bf7724e51bc75503570c;hp=6a776a8a236a5883069694345565510613347fee;hpb=6e8d04ac3e9074bffe25a1ef9e6b198caaa30385;p=mesa.git

diff --git a/src/mesa/state_tracker/st_manager.c b/src/mesa/state_tracker/st_manager.c
index 6a776a8a236..7abd128e719 100644
--- a/src/mesa/state_tracker/st_manager.c
+++ b/src/mesa/state_tracker/st_manager.c
@@ -26,6 +26,7 @@
  */
 
 #include "main/mtypes.h"
+#include "main/extensions.h"
 #include "main/context.h"
 #include "main/texobj.h"
 #include "main/teximage.h"
@@ -38,6 +39,7 @@
 #include "st_texture.h"
 
 #include "st_context.h"
+#include "st_extensions.h"
 #include "st_format.h"
 #include "st_cb_fbo.h"
 #include "st_cb_flush.h"
@@ -59,7 +61,7 @@
  * We'll only return non-null for window system framebuffers.
  * Note that this function may fail.
  */
-static INLINE struct st_framebuffer *
+static inline struct st_framebuffer *
 st_ws_framebuffer(struct gl_framebuffer *fb)
 {
    /* FBO cannot be casted.  See st_new_framebuffer */
@@ -71,7 +73,7 @@ st_ws_framebuffer(struct gl_framebuffer *fb)
 /**
  * Map an attachment to a buffer index.
  */
-static INLINE gl_buffer_index
+static inline gl_buffer_index
 attachment_to_buffer_index(enum st_attachment_type statt)
 {
    gl_buffer_index index;
@@ -107,7 +109,7 @@ attachment_to_buffer_index(enum st_attachment_type statt)
 /**
  * Map a buffer index to an attachment.
  */
-static INLINE enum st_attachment_type
+static inline enum st_attachment_type
 buffer_index_to_attachment(gl_buffer_index index)
 {
    enum st_attachment_type statt;
@@ -183,8 +185,13 @@ st_framebuffer_validate(struct st_framebuffer *stfb,
    uint width, height;
    unsigned i;
    boolean changed = FALSE;
-   int32_t new_stamp = p_atomic_read(&stfb->iface->stamp);
+   int32_t new_stamp;
 
+   /* Check for incomplete framebuffers (e.g. EGL_KHR_surfaceless_context) */
+   if (!stfb->iface)
+      return;
+
+   new_stamp = p_atomic_read(&stfb->iface->stamp);
    if (stfb->iface_stamp == new_stamp)
       return;
 
@@ -302,6 +309,8 @@ st_framebuffer_add_renderbuffer(struct st_framebuffer *stfb,
       break;
    default:
       format = stfb->iface->visual->color_format;
+      if (stfb->Base.Visual.sRGBCapable)
+         format = util_format_srgb(format);
       sw = FALSE;
       break;
    }
@@ -359,6 +368,7 @@ st_visual_to_context_mode(const struct st_visual *visual,
 
       mode->rgbBits = mode->redBits +
          mode->greenBits + mode->blueBits + mode->alphaBits;
+      mode->sRGBCapable = util_format_is_srgb(visual->color_format);
    }
 
    if (visual->depth_stencil_format != PIPE_FORMAT_NONE) {
@@ -400,7 +410,8 @@ st_visual_to_context_mode(const struct st_visual *visual,
  * Create a framebuffer from a manager interface.
  */
 static struct st_framebuffer *
-st_framebuffer_create(struct st_framebuffer_iface *stfbi)
+st_framebuffer_create(struct st_context *st,
+                      struct st_framebuffer_iface *stfbi)
 {
    struct st_framebuffer *stfb;
    struct gl_config mode;
@@ -414,6 +425,39 @@ st_framebuffer_create(struct st_framebuffer_iface *stfbi)
       return NULL;
 
    st_visual_to_context_mode(stfbi->visual, &mode);
+
+   /*
+    * For desktop GL, sRGB framebuffer write is controlled by both the
+    * capability of the framebuffer and GL_FRAMEBUFFER_SRGB.  We should
+    * advertise the capability when the pipe driver (and core Mesa) supports
+    * it so that applications can enable sRGB write when they want to.
+    *
+    * This is not to be confused with GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB.  When
+    * the attribute is GLX_TRUE, it tells the st manager to pick a color
+    * format such that util_format_srgb(visual->color_format) can be supported
+    * by the pipe driver.  We still need to advertise the capability here.
+    *
+    * For GLES, however, sRGB framebuffer write is controlled only by the
+    * capability of the framebuffer.  There is GL_EXT_sRGB_write_control to
+    * give applications the control back, but sRGB write is still enabled by
+    * default.  To avoid unexpected results, we should not advertise the
+    * capability.  This could change when we add support for
+    * EGL_KHR_gl_colorspace.
+    */
+   if (_mesa_is_desktop_gl(st->ctx)) {
+      struct pipe_screen *screen = st->pipe->screen;
+      const enum pipe_format srgb_format =
+         util_format_srgb(stfbi->visual->color_format);
+
+      if (srgb_format != PIPE_FORMAT_NONE &&
+          st_pipe_format_to_mesa_format(srgb_format) != MESA_FORMAT_NONE &&
+          screen->is_format_supported(screen, srgb_format,
+                                      PIPE_TEXTURE_2D, stfbi->visual->samples,
+                                      (PIPE_BIND_DISPLAY_TARGET |
+                                       PIPE_BIND_RENDER_TARGET)))
+         mode.sRGBCapable = GL_TRUE;
+   }
+
    _mesa_initialize_window_framebuffer(&stfb->Base, &mode);
 
    stfb->iface = stfbi;
@@ -613,7 +657,7 @@ st_api_create_context(struct st_api *stapi, struct st_manager *smapi,
       break;
    }
 
-   pipe = smapi->screen->context_create(smapi->screen, NULL);
+   pipe = smapi->screen->context_create(smapi->screen, NULL, 0);
    if (!pipe) {
       *error = ST_CONTEXT_ERROR_NO_MEMORY;
       return NULL;
@@ -628,23 +672,25 @@ st_api_create_context(struct st_api *stapi, struct st_manager *smapi,
    }
 
    if (attribs->flags & ST_CONTEXT_FLAG_DEBUG){
-      struct gl_debug_state *debug = _mesa_get_debug_state(st->ctx);
-      if (!debug) {
+      if (!_mesa_set_debug_state_int(st->ctx, GL_DEBUG_OUTPUT, GL_TRUE)) {
          *error = ST_CONTEXT_ERROR_NO_MEMORY;
          return NULL;
       }
       st->ctx->Const.ContextFlags |= GL_CONTEXT_FLAG_DEBUG_BIT;
-      debug->DebugOutput = GL_TRUE;
    }
 
    if (attribs->flags & ST_CONTEXT_FLAG_FORWARD_COMPATIBLE)
       st->ctx->Const.ContextFlags |= GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT;
+   if (attribs->flags & ST_CONTEXT_FLAG_ROBUST_ACCESS)
+      st->ctx->Const.ContextFlags |= GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB;
+   if (attribs->flags & ST_CONTEXT_FLAG_RESET_NOTIFICATION_ENABLED)
+      st->ctx->Const.ResetStrategy = GL_LOSE_CONTEXT_ON_RESET_ARB;
 
    /* need to perform version check */
    if (attribs->major > 1 || attribs->minor > 0) {
       /* Is the actual version less than the requested version?
        */
-      if (st->ctx->Version < attribs->major * 10 + attribs->minor) {
+      if (st->ctx->Version < attribs->major * 10U + attribs->minor) {
 	 *error = ST_CONTEXT_ERROR_BAD_VERSION;
          st_destroy_context(st);
          return NULL;
@@ -677,7 +723,8 @@ st_api_get_current(struct st_api *stapi)
 }
 
 static struct st_framebuffer *
-st_framebuffer_reuse_or_create(struct gl_framebuffer *fb,
+st_framebuffer_reuse_or_create(struct st_context *st,
+                               struct gl_framebuffer *fb,
                                struct st_framebuffer_iface *stfbi)
 {
    struct st_framebuffer *cur = st_ws_framebuffer(fb), *stfb = NULL;
@@ -690,7 +737,7 @@ st_framebuffer_reuse_or_create(struct gl_framebuffer *fb,
    }
    else {
       /* create a new one */
-      stfb = st_framebuffer_create(stfbi);
+      stfb = st_framebuffer_create(st, stfbi);
    }
 
    return stfb;
@@ -709,12 +756,12 @@ st_api_make_current(struct st_api *stapi, struct st_context_iface *stctxi,
 
    if (st) {
       /* reuse or create the draw fb */
-      stdraw = st_framebuffer_reuse_or_create(st->ctx->WinSysDrawBuffer,
-                                              stdrawi);
+      stdraw = st_framebuffer_reuse_or_create(st,
+            st->ctx->WinSysDrawBuffer, stdrawi);
       if (streadi != stdrawi) {
          /* do the same for the read fb */
-         stread = st_framebuffer_reuse_or_create(st->ctx->WinSysReadBuffer,
-                                                 streadi);
+         stread = st_framebuffer_reuse_or_create(st,
+               st->ctx->WinSysReadBuffer, streadi);
       }
       else {
          stread = NULL;
@@ -871,6 +918,40 @@ st_manager_add_color_renderbuffer(struct st_context *st,
    return TRUE;
 }
 
+static unsigned get_version(struct pipe_screen *screen,
+                            struct st_config_options *options, gl_api api)
+{
+   struct gl_constants consts = {0};
+   struct gl_extensions extensions = {0};
+   GLuint version;
+
+   if (_mesa_override_gl_version_contextless(&consts, &api, &version)) {
+      return version;
+   }
+
+   _mesa_init_constants(&consts, api);
+   _mesa_init_extensions(&extensions);
+
+   st_init_limits(screen, &consts, &extensions);
+   st_init_extensions(screen, &consts, &extensions, options, GL_TRUE);
+
+   return _mesa_get_version(&extensions, &consts, api);
+}
+
+static void
+st_api_query_versions(struct st_api *stapi, struct st_manager *sm,
+                      struct st_config_options *options,
+                      int *gl_core_version,
+                      int *gl_compat_version,
+                      int *gl_es1_version,
+                      int *gl_es2_version)
+{
+   *gl_core_version = get_version(sm->screen, options, API_OPENGL_CORE);
+   *gl_compat_version = get_version(sm->screen, options, API_OPENGL_COMPAT);
+   *gl_es1_version = get_version(sm->screen, options, API_OPENGLES);
+   *gl_es2_version = get_version(sm->screen, options, API_OPENGLES2);
+}
+
 static const struct st_api st_gl_api = {
    "Mesa " PACKAGE_VERSION,
    ST_API_OPENGL,
@@ -881,6 +962,7 @@ static const struct st_api st_gl_api = {
    0,
    ST_API_FEATURE_MS_VISUALS_MASK,
    st_api_destroy,
+   st_api_query_versions,
    st_api_get_proc_address,
    st_api_create_context,
    st_api_make_current,