sungmg/mutter-performance-source
1
0
Fork 0
Code Activity
mutter-performance-source/cogl/winsys/cogl-winsys-egl-kms.c

1012 lines
30 KiB
C
Raw Normal View History

Add a separate winsys vtable for each EGL platform Instead of just having an "EGL" renderer, there is now a separate winsys for each platform. Currently they just directly copy the vtable for the EGL platform so it is still only possible to have one EGL platform compiled into Cogl. However the intention is that the winsys-specific code for each platform will be moved into override functions in the corresponding platform winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-08 17:24:40 +00:00
/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2011 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <http://www.gnu.org/licenses/>.
*
*
* Authors:
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
* Rob Bradford <rob@linux.intel.com>
* Kristian Høgsberg (from eglkms.c)
* Benjamin Franzke (from eglkms.c)
Add a separate winsys vtable for each EGL platform Instead of just having an "EGL" renderer, there is now a separate winsys for each platform. Currently they just directly copy the vtable for the EGL platform so it is still only possible to have one EGL platform compiled into Cogl. However the intention is that the winsys-specific code for each platform will be moved into override functions in the corresponding platform winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-08 17:24:40 +00:00
* Robert Bragg <robert@linux.intel.com>
* Neil Roberts <neil@linux.intel.com>
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <drm.h>
egl-kms: Use drmModePageFlip The KMS platform now uses drmModePageFlip to present the buffer. The main loop mechanism is used to poll for events on the DRM file descriptor so that we notice when the page flip is complete. The swap_buffers is throttled so that if there is a pending flip it will block until it is complete before starting another flip. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 17:17:28 +00:00
#include <xf86drm.h>
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
#include <xf86drmMode.h>
#include <gbm.h>
#include <glib.h>
#include <sys/fcntl.h>
#include <unistd.h>
egl-kms: Use drmModePageFlip The KMS platform now uses drmModePageFlip to present the buffer. The main loop mechanism is used to poll for events on the DRM file descriptor so that we notice when the page flip is complete. The swap_buffers is throttled so that if there is a pending flip it will block until it is complete before starting another flip. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 17:17:28 +00:00
#include <string.h>
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
#include <stdlib.h>
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
Add a separate winsys vtable for each EGL platform Instead of just having an "EGL" renderer, there is now a separate winsys for each platform. Currently they just directly copy the vtable for the EGL platform so it is still only possible to have one EGL platform compiled into Cogl. However the intention is that the winsys-specific code for each platform will be moved into override functions in the corresponding platform winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-08 17:24:40 +00:00
#include "cogl-winsys-egl-kms-private.h"
#include "cogl-winsys-egl-private.h"
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
#include "cogl-renderer-private.h"
#include "cogl-framebuffer-private.h"
#include "cogl-onscreen-private.h"
Add -Wmissing-declarations to maintainer flags and fix problems This option to GCC makes it give a warning whenever a global function is defined without a declaration. This should catch cases were we've defined a function but forgot to put it in a header. In that case it is either only used within one file so we should make it static or we should declare it in a header. The following changes where made to fix problems: • Some functions were made static • cogl-path.h (the one containing the 1.0 API) was split into two files, one defining the functions and one defining the enums so that cogl-path.c can include the enum and function declarations from the 2.0 API as well as the function declarations from the 1.0 API. • cogl2-clip-state has been removed. This only had one experimental function called cogl_clip_push_from_path but as this is unstable we might as well remove it favour of the equivalent cogl_framebuffer_* API. • The GLX, SDL and WGL winsys's now have a private header to define their get_vtable function instead of directly declaring in the C file where it is called. • All places that were calling COGL_OBJECT_DEFINE need to have the cogl_is_whatever function declared so these have been added either as a public function or in a private header. • Some files that were not including the header containing their function declarations have been fixed to do so. • Any unused error quark functions have been removed. If we later want them we should add them back one by one and add a declaration for them in a header. • _cogl_is_framebuffer has been renamed to cogl_is_framebuffer and made a public function with a declaration in cogl-framebuffer.h • Similarly for CoglOnscreen. • cogl_vdraw_indexed_attributes is called cogl_framebuffer_vdraw_indexed_attributes in the header. The definition has been changed to match the header. • cogl_index_buffer_allocate has been removed. This had no declaration and I'm not sure what it's supposed to do. • CoglJournal has been changed to use the internal CoglObject macro so that it won't define an exported cogl_is_journal symbol. • The _cogl_blah_pointer_from_handle functions have been removed. CoglHandle isn't used much anymore anyway and in the few places where it is used I think it's safe to just use the implicit cast from void* to the right type. • The test-utils.h header for the conformance tests explicitly disables the -Wmissing-declaration option using a pragma because all of the tests declare their main function without a header. Any mistakes relating to missing declarations aren't really important for the tests. • cogl_quaternion_init_from_quaternion and init_from_matrix have been given declarations in cogl-quaternion.h Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-06 18:21:28 +00:00
#include "cogl-kms-renderer.h"
kms: defer setting crtc modes until first swap buffers Instead of creating a dummy framebuffer allocation just so we can setup crtc modes during display_setup we now wait until the first swap_buffers request before setting up the crtc modes. This patch also adds a cogl_kms_display_queue_modes_reset() function that allows developers to explicitly queue a reset of the crtc modes. The idea is that applications that handle VT switching can use this for VT enter events to explicitly ensure their mode is restored since modes are often not automatically restored correctly. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-30 11:06:41 +00:00
#include "cogl-kms-display.h"
kms: Fix the version check for GBM The check for whether to use ‘stride’ instead of ‘pitch’ from the GBM API tries to check whether the GBM version is >= 8.1.0. However it was comparing the major and micro components independently so any version with the minor part set to 0 would fail. The GBM version in Mesa master is now 9.0.0 which breaks it. This patch changes it to check the version using the COGL_VERSION_ENCODE macro instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 38f1dc58b35023f9e6bbc0db746b1554bd0377fc)
2012-09-06 16:33:20 +00:00
#include "cogl-version.h"
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
#include "cogl-error-private.h"
Move event polling into CoglRenderer This updates the cogl_poll_ apis to allow dispatching events before we have a CoglContext and to also enables pollfd state to be changed in a more add-hoc way by different Cogl components by replacing the winsys->get_poll_info with _cogl_poll_renderer_add/remove_fd functions and a winsys->get_dispatch_timeout vfunc. One of the intentions here is that applications should be able to run their mainloop before creating a CoglContext to potentially get events relating to CoglOutputs. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 667e58c9cb2662aef5f44e580a9eda42dc8d0176)
2013-04-16 22:46:03 +00:00
#include "cogl-poll-private.h"
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
static const CoglWinsysEGLVtable _cogl_winsys_egl_vtable;
kms: Use GBM surfaces Instead of creating FBOs on the GL side, the KMS EGL platform uses the latest changes to Mesa to create an EGL surface using a GBM surface as the native surface type. This removes some of the special vtable hooks that the KMS platform needed because it is now much more similar to the other platforms. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 15:37:26 +00:00
static const CoglWinsysVtable *parent_vtable;
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
typedef struct _CoglRendererKMS
{
int fd;
struct gbm_device *gbm;
Add api for queuing idle callback internally This adds a _cogl_poll_renderer_add_idle api that can be used internally for queuing an idle callback without needing to make any assumption about the system mainloop that is being used. This is now used to avoid having the _cogl_poll_renderer_dispatch() directly check for all kinds of events to dispatch, and to avoid having the winsys dispatch vfuncs need to directly know about CoglContext. This means we can now avoid having a back reference from CoglRenderer to the CoglContext. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit a1e169f18f4257caec58760adccfe4ec09b9805d)
2013-04-18 13:19:43 +00:00
CoglClosure *swap_notify_idle;
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
} CoglRendererKMS;
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
typedef struct _CoglOutputKMS
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
{
drmModeConnector *connector;
drmModeEncoder *encoder;
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
drmModeCrtc *saved_crtc;
drmModeModeInfo *modes;
int n_modes;
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
drmModeModeInfo mode;
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
} CoglOutputKMS;
typedef struct _CoglDisplayKMS
{
GList *outputs;
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
int width, height;
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
CoglBool pending_set_crtc;
kms: Use a dummy surface instead of the surfaceless extension The surfaceless extension that Mesa advertises has been renamed to EGL_KHR_surfaceless_context instead of a separate extension for the GLES, GLES2 and GL APIs and the new extension has been ratified by Khronos. Therefore the KMS backend no longer runs against Mesa master. We could just rename the extension we check for, however Weston (the sample Wayland compositor) has switched to just creating a dummy GBM surface and not using the surfaceless extension at all. We should probably do the same thing. Using the surfaceless extension could be a good idea but we don't really need to rely on it for KMS and we would want to do it for all EGL backends, not just the KMS backend. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit d4f22f8cb013d417c99ba03924538924191c2fe6)
2012-08-13 14:43:30 +00:00
struct gbm_surface *dummy_gbm_surface;
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
} CoglDisplayKMS;
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
typedef struct _CoglFlipKMS
{
CoglOnscreen *onscreen;
int pending;
} CoglFlipKMS;
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
typedef struct _CoglOnscreenKMS
{
kms: Use GBM surfaces Instead of creating FBOs on the GL side, the KMS EGL platform uses the latest changes to Mesa to create an EGL surface using a GBM surface as the native surface type. This removes some of the special vtable hooks that the KMS platform needed because it is now much more similar to the other platforms. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 15:37:26 +00:00
struct gbm_surface *surface;
uint32_t current_fb_id;
uint32_t next_fb_id;
struct gbm_bo *current_bo;
struct gbm_bo *next_bo;
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
CoglBool pending_swap_notify;
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
} CoglOnscreenKMS;
static const char device_name[] = "/dev/dri/card0";
static void
_cogl_winsys_renderer_disconnect (CoglRenderer *renderer)
{
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglRendererKMS *kms_renderer = egl_renderer->platform;
eglTerminate (egl_renderer->edpy);
g_slice_free (CoglRendererKMS, kms_renderer);
g_slice_free (CoglRendererEGL, egl_renderer);
}
Associate check and dispatch funcs with poll fds Instead of driving event dispatching through a per winsys poll_dispatch vfunc its now possible to associate a check and dispatch function with each file descriptor that is registered for polling. This means we can remove the winsys get_dispatch_timeout and poll_dispatch vfuncs and it also makes it easier for more orthogonal internal components to add file descriptors for polling to the mainloop. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 627947622df36dd529b9dc60a3ae9e6083532b19)
2013-04-18 15:26:21 +00:00
static void
flush_pending_swap_notify_cb (void *data,
void *user_data)
{
CoglFramebuffer *framebuffer = data;
if (framebuffer->type == COGL_FRAMEBUFFER_TYPE_ONSCREEN)
{
CoglOnscreen *onscreen = COGL_ONSCREEN (framebuffer);
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglOnscreenKMS *kms_onscreen = egl_onscreen->platform;
if (kms_onscreen->pending_swap_notify)
{
CoglFrameInfo *info = g_queue_pop_head (&onscreen->pending_frame_infos);
_cogl_onscreen_notify_frame_sync (onscreen, info);
_cogl_onscreen_notify_complete (onscreen, info);
kms_onscreen->pending_swap_notify = FALSE;
cogl_object_unref (info);
}
}
}
static void
flush_pending_swap_notify_idle (void *user_data)
{
CoglContext *context = user_data;
CoglRendererEGL *egl_renderer = context->display->renderer->winsys;
CoglRendererKMS *kms_renderer = egl_renderer->platform;
/* This needs to be disconnected before invoking the callbacks in
* case the callbacks cause it to be queued again */
_cogl_closure_disconnect (kms_renderer->swap_notify_idle);
kms_renderer->swap_notify_idle = NULL;
g_list_foreach (context->framebuffers,
flush_pending_swap_notify_cb,
NULL);
}
static void
free_current_bo (CoglOnscreen *onscreen)
{
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglOnscreenKMS *kms_onscreen = egl_onscreen->platform;
CoglContext *context = COGL_FRAMEBUFFER (onscreen)->context;
CoglRenderer *renderer = context->display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglRendererKMS *kms_renderer = egl_renderer->platform;
if (kms_onscreen->current_fb_id)
{
drmModeRmFB (kms_renderer->fd,
kms_onscreen->current_fb_id);
kms_onscreen->current_fb_id = 0;
}
if (kms_onscreen->current_bo)
{
gbm_surface_release_buffer (kms_onscreen->surface,
kms_onscreen->current_bo);
kms_onscreen->current_bo = NULL;
}
}
static void
page_flip_handler (int fd,
unsigned int frame,
unsigned int sec,
unsigned int usec,
void *data)
{
CoglFlipKMS *flip = data;
/* We're only ready to dispatch a swap notification once all outputs
* have flipped... */
flip->pending--;
if (flip->pending == 0)
{
CoglOnscreen *onscreen = flip->onscreen;
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglOnscreenKMS *kms_onscreen = egl_onscreen->platform;
CoglContext *context = COGL_FRAMEBUFFER (onscreen)->context;
CoglRenderer *renderer = context->display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglRendererKMS *kms_renderer = egl_renderer->platform;
/* We only want to notify that the swap is complete when the
* application calls cogl_context_dispatch so instead of
* immediately notifying we queue an idle callback */
if (!kms_renderer->swap_notify_idle)
{
kms_renderer->swap_notify_idle =
_cogl_poll_renderer_add_idle (renderer,
flush_pending_swap_notify_idle,
context,
NULL);
}
kms_onscreen->pending_swap_notify = TRUE;
free_current_bo (onscreen);
kms_onscreen->current_fb_id = kms_onscreen->next_fb_id;
kms_onscreen->next_fb_id = 0;
kms_onscreen->current_bo = kms_onscreen->next_bo;
kms_onscreen->next_bo = NULL;
cogl_object_unref (flip->onscreen);
g_slice_free (CoglFlipKMS, flip);
}
}
static void
handle_drm_event (CoglRendererKMS *kms_renderer)
{
drmEventContext evctx;
memset (&evctx, 0, sizeof evctx);
evctx.version = DRM_EVENT_CONTEXT_VERSION;
evctx.page_flip_handler = page_flip_handler;
drmHandleEvent (kms_renderer->fd, &evctx);
}
static void
poll: Add general way to hook into mainloop without fd This adds a _cogl_poll_renderer_add_source() function that we can use within cogl to hook into the mainloop without necessarily having a file descriptor to poll. Since the intention is to use this to support polling for fence completions this also updates the CoglPollCheckCallback type to take a timeout pointer so sources can optionally update the timeout that will be passed to poll. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 81c1ce0ffce4e75e08622e20848405987e00b3cc)
2013-05-14 01:51:55 +00:00
dispatch_kms_events (void *user_data, int revents)
Associate check and dispatch funcs with poll fds Instead of driving event dispatching through a per winsys poll_dispatch vfunc its now possible to associate a check and dispatch function with each file descriptor that is registered for polling. This means we can remove the winsys get_dispatch_timeout and poll_dispatch vfuncs and it also makes it easier for more orthogonal internal components to add file descriptors for polling to the mainloop. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 627947622df36dd529b9dc60a3ae9e6083532b19)
2013-04-18 15:26:21 +00:00
{
CoglRenderer *renderer = user_data;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglRendererKMS *kms_renderer = egl_renderer->platform;
poll: Add general way to hook into mainloop without fd This adds a _cogl_poll_renderer_add_source() function that we can use within cogl to hook into the mainloop without necessarily having a file descriptor to poll. Since the intention is to use this to support polling for fence completions this also updates the CoglPollCheckCallback type to take a timeout pointer so sources can optionally update the timeout that will be passed to poll. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 81c1ce0ffce4e75e08622e20848405987e00b3cc)
2013-05-14 01:51:55 +00:00
if (!revents)
return;
Associate check and dispatch funcs with poll fds Instead of driving event dispatching through a per winsys poll_dispatch vfunc its now possible to associate a check and dispatch function with each file descriptor that is registered for polling. This means we can remove the winsys get_dispatch_timeout and poll_dispatch vfuncs and it also makes it easier for more orthogonal internal components to add file descriptors for polling to the mainloop. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 627947622df36dd529b9dc60a3ae9e6083532b19)
2013-04-18 15:26:21 +00:00
handle_drm_event (kms_renderer);
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
static CoglBool
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
_cogl_winsys_renderer_connect (CoglRenderer *renderer,
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
CoglError **error)
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
{
CoglRendererEGL *egl_renderer;
CoglRendererKMS *kms_renderer;
renderer->winsys = g_slice_new0 (CoglRendererEGL);
egl_renderer = renderer->winsys;
egl_renderer->platform_vtable = &_cogl_winsys_egl_vtable;
egl_renderer->platform = g_slice_new0 (CoglRendererKMS);
kms_renderer = egl_renderer->platform;
egl-kms: set the EGL_PLATFORM explicitly Otherwise, if we try egl-wayland first, we get the environment variable from that, which crashes mesa trying to open the gbm device as a wayland display. https://bugzilla.gnome.org/show_bug.cgi?id=705836
2013-07-17 12:08:32 +00:00
/* The EGL API doesn't provide for a way to explicitly select a
* platform when the driver can support multiple. Mesa allows
* selection using an environment variable though so that's what
* we're doing here... */
g_setenv ("EGL_PLATFORM", "drm", 1);
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
kms_renderer->fd = open (device_name, O_RDWR);
if (kms_renderer->fd < 0)
{
/* Probably permissions error */
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
_cogl_set_error (error, COGL_WINSYS_ERROR,
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
COGL_WINSYS_ERROR_INIT,
"Couldn't open %s", device_name);
return FALSE;
}
kms_renderer->gbm = gbm_create_device (kms_renderer->fd);
if (kms_renderer->gbm == NULL)
{
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
_cogl_set_error (error, COGL_WINSYS_ERROR,
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
COGL_WINSYS_ERROR_INIT,
"Couldn't create gbm device");
goto close_fd;
}
egl_renderer->edpy = eglGetDisplay ((EGLNativeDisplayType)kms_renderer->gbm);
if (egl_renderer->edpy == EGL_NO_DISPLAY)
{
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
_cogl_set_error (error, COGL_WINSYS_ERROR,
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
COGL_WINSYS_ERROR_INIT,
"Couldn't get eglDisplay");
goto destroy_gbm_device;
}
if (!_cogl_winsys_egl_renderer_connect_common (renderer, error))
goto egl_terminate;
Move event polling into CoglRenderer This updates the cogl_poll_ apis to allow dispatching events before we have a CoglContext and to also enables pollfd state to be changed in a more add-hoc way by different Cogl components by replacing the winsys->get_poll_info with _cogl_poll_renderer_add/remove_fd functions and a winsys->get_dispatch_timeout vfunc. One of the intentions here is that applications should be able to run their mainloop before creating a CoglContext to potentially get events relating to CoglOutputs. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 667e58c9cb2662aef5f44e580a9eda42dc8d0176)
2013-04-16 22:46:03 +00:00
_cogl_poll_renderer_add_fd (renderer,
kms_renderer->fd,
Associate check and dispatch funcs with poll fds Instead of driving event dispatching through a per winsys poll_dispatch vfunc its now possible to associate a check and dispatch function with each file descriptor that is registered for polling. This means we can remove the winsys get_dispatch_timeout and poll_dispatch vfuncs and it also makes it easier for more orthogonal internal components to add file descriptors for polling to the mainloop. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 627947622df36dd529b9dc60a3ae9e6083532b19)
2013-04-18 15:26:21 +00:00
COGL_POLL_FD_EVENT_IN,
poll: Add general way to hook into mainloop without fd This adds a _cogl_poll_renderer_add_source() function that we can use within cogl to hook into the mainloop without necessarily having a file descriptor to poll. Since the intention is to use this to support polling for fence completions this also updates the CoglPollCheckCallback type to take a timeout pointer so sources can optionally update the timeout that will be passed to poll. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 81c1ce0ffce4e75e08622e20848405987e00b3cc)
2013-05-14 01:51:55 +00:00
NULL, /* no prepare callback */
Associate check and dispatch funcs with poll fds Instead of driving event dispatching through a per winsys poll_dispatch vfunc its now possible to associate a check and dispatch function with each file descriptor that is registered for polling. This means we can remove the winsys get_dispatch_timeout and poll_dispatch vfuncs and it also makes it easier for more orthogonal internal components to add file descriptors for polling to the mainloop. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 627947622df36dd529b9dc60a3ae9e6083532b19)
2013-04-18 15:26:21 +00:00
dispatch_kms_events,
renderer);
egl-kms: Use drmModePageFlip The KMS platform now uses drmModePageFlip to present the buffer. The main loop mechanism is used to poll for events on the DRM file descriptor so that we notice when the page flip is complete. The swap_buffers is throttled so that if there is a pending flip it will block until it is complete before starting another flip. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 17:17:28 +00:00
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
return TRUE;
egl_terminate:
eglTerminate (egl_renderer->edpy);
destroy_gbm_device:
gbm_device_destroy (kms_renderer->gbm);
close_fd:
close (kms_renderer->fd);
_cogl_winsys_renderer_disconnect (renderer);
return FALSE;
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
static CoglBool
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
is_connector_excluded (int id,
int *excluded_connectors,
int n_excluded_connectors)
{
int i;
for (i = 0; i < n_excluded_connectors; i++)
if (excluded_connectors[i] == id)
return TRUE;
return FALSE;
}
static drmModeConnector *
find_connector (int fd,
drmModeRes *resources,
int *excluded_connectors,
int n_excluded_connectors)
{
int i;
for (i = 0; i < resources->count_connectors; i++)
{
drmModeConnector *connector =
drmModeGetConnector (fd, resources->connectors[i]);
if (connector &&
connector->connection == DRM_MODE_CONNECTED &&
connector->count_modes > 0 &&
!is_connector_excluded (connector->connector_id,
excluded_connectors,
n_excluded_connectors))
return connector;
drmModeFreeConnector(connector);
}
return NULL;
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
static CoglBool
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
find_mirror_modes (drmModeModeInfo *modes0,
int n_modes0,
drmModeModeInfo *modes1,
int n_modes1,
drmModeModeInfo *mode1_out,
drmModeModeInfo *mode0_out)
{
int i;
for (i = 0; i < n_modes0; i++)
{
int j;
drmModeModeInfo *mode0 = &modes0[i];
for (j = 0; j < n_modes1; j++)
{
drmModeModeInfo *mode1 = &modes1[j];
if (mode1->hdisplay == mode0->hdisplay &&
mode1->vdisplay == mode0->vdisplay)
{
*mode0_out = *mode0;
*mode1_out = *mode1;
return TRUE;
}
}
}
return FALSE;
}
static drmModeModeInfo builtin_1024x768 =
{
63500, /* clock */
1024, 1072, 1176, 1328, 0,
768, 771, 775, 798, 0,
59920,
DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC,
0,
"1024x768"
};
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
static CoglBool
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
is_panel (int type)
{
return (type == DRM_MODE_CONNECTOR_LVDS ||
type == DRM_MODE_CONNECTOR_eDP);
}
static CoglOutputKMS *
find_output (int _index,
int fd,
drmModeRes *resources,
int *excluded_connectors,
int n_excluded_connectors,
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
CoglError **error)
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
{
char *connector_env_name = g_strdup_printf ("COGL_KMS_CONNECTOR%d", _index);
char *mode_env_name;
drmModeConnector *connector;
drmModeEncoder *encoder;
CoglOutputKMS *output;
drmModeModeInfo *modes;
int n_modes;
if (getenv (connector_env_name))
{
unsigned long id = strtoul (getenv (connector_env_name), NULL, 10);
connector = drmModeGetConnector (fd, id);
}
else
connector = NULL;
g_free (connector_env_name);
if (connector == NULL)
connector = find_connector (fd, resources,
excluded_connectors, n_excluded_connectors);
if (connector == NULL)
{
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
_cogl_set_error (error, COGL_WINSYS_ERROR,
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
COGL_WINSYS_ERROR_INIT,
"No currently active connector found");
return NULL;
}
/* XXX: At this point it seems connector->encoder_id may be an invalid id of 0
* even though the connector is marked as connected. Referencing ->encoders[0]
* seems more reliable. */
encoder = drmModeGetEncoder (fd, connector->encoders[0]);
output = g_slice_new0 (CoglOutputKMS);
output->connector = connector;
output->encoder = encoder;
output->saved_crtc = drmModeGetCrtc (fd, encoder->crtc_id);
if (is_panel (connector->connector_type))
{
n_modes = connector->count_modes + 1;
modes = g_new (drmModeModeInfo, n_modes);
memcpy (modes, connector->modes,
sizeof (drmModeModeInfo) * connector->count_modes);
/* TODO: parse EDID */
modes[n_modes - 1] = builtin_1024x768;
}
else
{
n_modes = connector->count_modes;
modes = g_new (drmModeModeInfo, n_modes);
memcpy (modes, connector->modes,
sizeof (drmModeModeInfo) * n_modes);
}
mode_env_name = g_strdup_printf ("COGL_KMS_CONNECTOR%d_MODE", _index);
if (getenv (mode_env_name))
{
const char *name = getenv (mode_env_name);
int i;
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
CoglBool found = FALSE;
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
drmModeModeInfo mode;
for (i = 0; i < n_modes; i++)
{
if (strcmp (modes[i].name, name) == 0)
{
found = TRUE;
break;
}
}
if (!found)
{
g_free (mode_env_name);
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
_cogl_set_error (error, COGL_WINSYS_ERROR,
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
COGL_WINSYS_ERROR_INIT,
"COGL_KMS_CONNECTOR%d_MODE of %s could not be found",
_index, name);
return NULL;
}
n_modes = 1;
mode = modes[i];
g_free (modes);
modes = g_new (drmModeModeInfo, 1);
modes[0] = mode;
}
g_free (mode_env_name);
output->modes = modes;
output->n_modes = n_modes;
return output;
}
kms: defer setting crtc modes until first swap buffers Instead of creating a dummy framebuffer allocation just so we can setup crtc modes during display_setup we now wait until the first swap_buffers request before setting up the crtc modes. This patch also adds a cogl_kms_display_queue_modes_reset() function that allows developers to explicitly queue a reset of the crtc modes. The idea is that applications that handle VT switching can use this for VT enter events to explicitly ensure their mode is restored since modes are often not automatically restored correctly. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-30 11:06:41 +00:00
static void
setup_crtc_modes (CoglDisplay *display, int fb_id)
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
{
kms: defer setting crtc modes until first swap buffers Instead of creating a dummy framebuffer allocation just so we can setup crtc modes during display_setup we now wait until the first swap_buffers request before setting up the crtc modes. This patch also adds a cogl_kms_display_queue_modes_reset() function that allows developers to explicitly queue a reset of the crtc modes. The idea is that applications that handle VT switching can use this for VT enter events to explicitly ensure their mode is restored since modes are often not automatically restored correctly. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-30 11:06:41 +00:00
CoglDisplayEGL *egl_display = display->winsys;
CoglDisplayKMS *kms_display = egl_display->platform;
CoglRendererEGL *egl_renderer = display->renderer->winsys;
CoglRendererKMS *kms_renderer = egl_renderer->platform;
GList *l;
for (l = kms_display->outputs; l; l = l->next)
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
{
kms: defer setting crtc modes until first swap buffers Instead of creating a dummy framebuffer allocation just so we can setup crtc modes during display_setup we now wait until the first swap_buffers request before setting up the crtc modes. This patch also adds a cogl_kms_display_queue_modes_reset() function that allows developers to explicitly queue a reset of the crtc modes. The idea is that applications that handle VT switching can use this for VT enter events to explicitly ensure their mode is restored since modes are often not automatically restored correctly. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-30 11:06:41 +00:00
CoglOutputKMS *output = l->data;
int ret = drmModeSetCrtc (kms_renderer->fd,
output->encoder->crtc_id,
fb_id, 0, 0,
&output->connector->connector_id, 1,
&output->mode);
if (ret)
g_warning ("Failed to set crtc mode %s: %m", output->mode.name);
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
}
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
static CoglBool
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
_cogl_winsys_egl_display_setup (CoglDisplay *display,
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
CoglError **error)
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
{
CoglDisplayEGL *egl_display = display->winsys;
CoglDisplayKMS *kms_display;
CoglRendererEGL *egl_renderer = display->renderer->winsys;
CoglRendererKMS *kms_renderer = egl_renderer->platform;
drmModeRes *resources;
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
CoglOutputKMS *output0, *output1;
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
CoglBool mirror;
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
kms_display = g_slice_new0 (CoglDisplayKMS);
egl_display->platform = kms_display;
resources = drmModeGetResources (kms_renderer->fd);
if (!resources)
{
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
_cogl_set_error (error, COGL_WINSYS_ERROR,
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
COGL_WINSYS_ERROR_INIT,
"drmModeGetResources failed");
return FALSE;
}
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
output0 = find_output (0,
kms_renderer->fd,
resources,
NULL,
0, /* n excluded connectors */
error);
kms_display->outputs = g_list_append (kms_display->outputs, output0);
if (!output0)
return FALSE;
if (getenv ("COGL_KMS_MIRROR"))
mirror = TRUE;
else
mirror = FALSE;
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
if (mirror)
{
int exclude_connector = output0->connector->connector_id;
output1 = find_output (1,
kms_renderer->fd,
resources,
&exclude_connector,
1, /* n excluded connectors */
error);
if (!output1)
return FALSE;
kms_display->outputs = g_list_append (kms_display->outputs, output1);
if (!find_mirror_modes (output0->modes, output0->n_modes,
output1->modes, output1->n_modes,
&output0->mode,
&output1->mode))
{
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
_cogl_set_error (error, COGL_WINSYS_ERROR,
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
COGL_WINSYS_ERROR_INIT,
"Failed to find matching modes for mirroring");
return FALSE;
}
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
}
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
else
output0->mode = output0->modes[0];
kms: defer setting crtc modes until first swap buffers Instead of creating a dummy framebuffer allocation just so we can setup crtc modes during display_setup we now wait until the first swap_buffers request before setting up the crtc modes. This patch also adds a cogl_kms_display_queue_modes_reset() function that allows developers to explicitly queue a reset of the crtc modes. The idea is that applications that handle VT switching can use this for VT enter events to explicitly ensure their mode is restored since modes are often not automatically restored correctly. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-30 11:06:41 +00:00
kms_display->width = output0->mode.hdisplay;
kms_display->height = output0->mode.vdisplay;
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
kms: defer setting crtc modes until first swap buffers Instead of creating a dummy framebuffer allocation just so we can setup crtc modes during display_setup we now wait until the first swap_buffers request before setting up the crtc modes. This patch also adds a cogl_kms_display_queue_modes_reset() function that allows developers to explicitly queue a reset of the crtc modes. The idea is that applications that handle VT switching can use this for VT enter events to explicitly ensure their mode is restored since modes are often not automatically restored correctly. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-30 11:06:41 +00:00
/* We defer setting the crtc modes until the first swap_buffers request of a
* CoglOnscreen framebuffer. */
kms_display->pending_set_crtc = TRUE;
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
return TRUE;
}
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
static void
output_free (int fd, CoglOutputKMS *output)
{
if (output->modes)
g_free (output->modes);
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
if (output->encoder)
drmModeFreeEncoder (output->encoder);
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
if (output->connector)
{
if (output->saved_crtc)
{
int ret = drmModeSetCrtc (fd,
output->saved_crtc->crtc_id,
output->saved_crtc->buffer_id,
output->saved_crtc->x,
output->saved_crtc->y,
&output->connector->connector_id, 1,
&output->saved_crtc->mode);
if (ret)
g_warning (G_STRLOC ": Error restoring saved CRTC");
}
drmModeFreeConnector (output->connector);
}
g_slice_free (CoglOutputKMS, output);
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
}
static void
_cogl_winsys_egl_display_destroy (CoglDisplay *display)
{
CoglDisplayEGL *egl_display = display->winsys;
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
CoglDisplayKMS *kms_display = egl_display->platform;
CoglRenderer *renderer = display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglRendererKMS *kms_renderer = egl_renderer->platform;
GList *l;
for (l = kms_display->outputs; l; l = l->next)
output_free (kms_renderer->fd, l->data);
g_list_free (kms_display->outputs);
kms_display->outputs = NULL;
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
g_slice_free (CoglDisplayKMS, egl_display->platform);
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
static CoglBool
kms: Use GBM surfaces Instead of creating FBOs on the GL side, the KMS EGL platform uses the latest changes to Mesa to create an EGL surface using a GBM surface as the native surface type. This removes some of the special vtable hooks that the KMS platform needed because it is now much more similar to the other platforms. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 15:37:26 +00:00
_cogl_winsys_egl_context_created (CoglDisplay *display,
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
CoglError **error)
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
{
CoglDisplayEGL *egl_display = display->winsys;
kms: Use a dummy surface instead of the surfaceless extension The surfaceless extension that Mesa advertises has been renamed to EGL_KHR_surfaceless_context instead of a separate extension for the GLES, GLES2 and GL APIs and the new extension has been ratified by Khronos. Therefore the KMS backend no longer runs against Mesa master. We could just rename the extension we check for, however Weston (the sample Wayland compositor) has switched to just creating a dummy GBM surface and not using the surfaceless extension at all. We should probably do the same thing. Using the surfaceless extension could be a good idea but we don't really need to rely on it for KMS and we would want to do it for all EGL backends, not just the KMS backend. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit d4f22f8cb013d417c99ba03924538924191c2fe6)
2012-08-13 14:43:30 +00:00
CoglDisplayKMS *kms_display = egl_display->platform;
CoglRenderer *renderer = display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglRendererKMS *kms_renderer = egl_renderer->platform;
kms_display->dummy_gbm_surface = gbm_surface_create (kms_renderer->gbm,
16, 16,
GBM_FORMAT_XRGB8888,
GBM_BO_USE_RENDERING);
if (!kms_display->dummy_gbm_surface)
{
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
_cogl_set_error (error, COGL_WINSYS_ERROR,
kms: Use a dummy surface instead of the surfaceless extension The surfaceless extension that Mesa advertises has been renamed to EGL_KHR_surfaceless_context instead of a separate extension for the GLES, GLES2 and GL APIs and the new extension has been ratified by Khronos. Therefore the KMS backend no longer runs against Mesa master. We could just rename the extension we check for, however Weston (the sample Wayland compositor) has switched to just creating a dummy GBM surface and not using the surfaceless extension at all. We should probably do the same thing. Using the surfaceless extension could be a good idea but we don't really need to rely on it for KMS and we would want to do it for all EGL backends, not just the KMS backend. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit d4f22f8cb013d417c99ba03924538924191c2fe6)
2012-08-13 14:43:30 +00:00
COGL_WINSYS_ERROR_CREATE_CONTEXT,
"Failed to create dummy GBM surface");
return FALSE;
}
egl_display->dummy_surface =
eglCreateWindowSurface (egl_renderer->edpy,
egl_display->egl_config,
(NativeWindowType) kms_display->dummy_gbm_surface,
NULL);
if (egl_display->dummy_surface == EGL_NO_SURFACE)
{
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
_cogl_set_error (error, COGL_WINSYS_ERROR,
kms: Use a dummy surface instead of the surfaceless extension The surfaceless extension that Mesa advertises has been renamed to EGL_KHR_surfaceless_context instead of a separate extension for the GLES, GLES2 and GL APIs and the new extension has been ratified by Khronos. Therefore the KMS backend no longer runs against Mesa master. We could just rename the extension we check for, however Weston (the sample Wayland compositor) has switched to just creating a dummy GBM surface and not using the surfaceless extension at all. We should probably do the same thing. Using the surfaceless extension could be a good idea but we don't really need to rely on it for KMS and we would want to do it for all EGL backends, not just the KMS backend. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit d4f22f8cb013d417c99ba03924538924191c2fe6)
2012-08-13 14:43:30 +00:00
COGL_WINSYS_ERROR_CREATE_CONTEXT,
"Failed to create dummy EGL surface");
return FALSE;
}
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
Adds initial GLES2 integration support This makes it possible to integrate existing GLES2 code with applications using Cogl as the rendering api. Currently all GLES2 usage is handled with separate GLES2 contexts to ensure that GLES2 api usage doesn't interfere with Cogl's own use of OpenGL[ES]. The api has been designed though so we can provide tighter integration later. The api would allow us to support GLES2 virtualized on top of an OpenGL/GLX driver as well as GLES2 virtualized on the core rendering api of Cogl itself. Virtualizing the GLES2 support on Cogl will allow us to take advantage of Cogl debugging facilities as well as let us optimize the cost of allocating multiple GLES2 contexts and switching between them which can both be very expensive with many drivers. As as a side effect of this patch Cogl can also now be used as a portable window system binding API for GLES2 as an alternative to EGL. Parts of this patch are based on work done by Tomeu Vizoso <tomeu.vizoso@collabora.com> who did the first iteration of adding GLES2 API support to Cogl so that WebGL support could be added to webkit-clutter. This patch adds a very minimal cogl-gles2-context example that shows how to create a gles2 context, clear the screen to a random color and also draw a triangle with the cogl api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 4bb6eff3dbd50d8fef7d6bdbed55c5aaa70036a8)
2012-03-06 03:21:30 +00:00
if (!_cogl_winsys_egl_make_current (display,
kms: Use a dummy surface instead of the surfaceless extension The surfaceless extension that Mesa advertises has been renamed to EGL_KHR_surfaceless_context instead of a separate extension for the GLES, GLES2 and GL APIs and the new extension has been ratified by Khronos. Therefore the KMS backend no longer runs against Mesa master. We could just rename the extension we check for, however Weston (the sample Wayland compositor) has switched to just creating a dummy GBM surface and not using the surfaceless extension at all. We should probably do the same thing. Using the surfaceless extension could be a good idea but we don't really need to rely on it for KMS and we would want to do it for all EGL backends, not just the KMS backend. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit d4f22f8cb013d417c99ba03924538924191c2fe6)
2012-08-13 14:43:30 +00:00
egl_display->dummy_surface,
egl_display->dummy_surface,
Adds initial GLES2 integration support This makes it possible to integrate existing GLES2 code with applications using Cogl as the rendering api. Currently all GLES2 usage is handled with separate GLES2 contexts to ensure that GLES2 api usage doesn't interfere with Cogl's own use of OpenGL[ES]. The api has been designed though so we can provide tighter integration later. The api would allow us to support GLES2 virtualized on top of an OpenGL/GLX driver as well as GLES2 virtualized on the core rendering api of Cogl itself. Virtualizing the GLES2 support on Cogl will allow us to take advantage of Cogl debugging facilities as well as let us optimize the cost of allocating multiple GLES2 contexts and switching between them which can both be very expensive with many drivers. As as a side effect of this patch Cogl can also now be used as a portable window system binding API for GLES2 as an alternative to EGL. Parts of this patch are based on work done by Tomeu Vizoso <tomeu.vizoso@collabora.com> who did the first iteration of adding GLES2 API support to Cogl so that WebGL support could be added to webkit-clutter. This patch adds a very minimal cogl-gles2-context example that shows how to create a gles2 context, clear the screen to a random color and also draw a triangle with the cogl api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 4bb6eff3dbd50d8fef7d6bdbed55c5aaa70036a8)
2012-03-06 03:21:30 +00:00
egl_display->egl_context))
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
{
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
_cogl_set_error (error, COGL_WINSYS_ERROR,
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
COGL_WINSYS_ERROR_CREATE_CONTEXT,
"Failed to make context current");
return FALSE;
}
return TRUE;
}
static void
_cogl_winsys_egl_cleanup_context (CoglDisplay *display)
{
kms: Use a dummy surface instead of the surfaceless extension The surfaceless extension that Mesa advertises has been renamed to EGL_KHR_surfaceless_context instead of a separate extension for the GLES, GLES2 and GL APIs and the new extension has been ratified by Khronos. Therefore the KMS backend no longer runs against Mesa master. We could just rename the extension we check for, however Weston (the sample Wayland compositor) has switched to just creating a dummy GBM surface and not using the surfaceless extension at all. We should probably do the same thing. Using the surfaceless extension could be a good idea but we don't really need to rely on it for KMS and we would want to do it for all EGL backends, not just the KMS backend. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit d4f22f8cb013d417c99ba03924538924191c2fe6)
2012-08-13 14:43:30 +00:00
CoglDisplayEGL *egl_display = display->winsys;
CoglDisplayKMS *kms_display = egl_display->platform;
CoglRenderer *renderer = display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
if (egl_display->dummy_surface != EGL_NO_SURFACE)
{
eglDestroySurface (egl_renderer->edpy, egl_display->dummy_surface);
egl_display->dummy_surface = EGL_NO_SURFACE;
}
if (kms_display->dummy_gbm_surface != NULL)
{
gbm_surface_destroy (kms_display->dummy_gbm_surface);
kms_display->dummy_gbm_surface = NULL;
}
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
}
static void
onscreen: Adds swap_buffers_with_damage api This adds api to be able requests a swap_buffers and also pass a list of damage rectangles that can be passed on to a compositor to enable it to minimize how much of the screen it needs to recompose. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 0d9684c7b7c2018bb42715c369555330d38514a2)
2012-02-07 17:59:51 +00:00
_cogl_winsys_onscreen_swap_buffers_with_damage (CoglOnscreen *onscreen,
const int *rectangles,
int n_rectangles)
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
{
CoglContext *context = COGL_FRAMEBUFFER (onscreen)->context;
CoglDisplayEGL *egl_display = context->display->winsys;
CoglDisplayKMS *kms_display = egl_display->platform;
CoglRenderer *renderer = context->display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglRendererKMS *kms_renderer = egl_renderer->platform;
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglOnscreenKMS *kms_onscreen = egl_onscreen->platform;
kms: Update to latest gbm api gbm_bo_get_pitch was renamed to gbm_bo_get_stride to be consistent with how the terms pitch and stride are used throughout mesa. This updates the Cogl backend to use the new gbm_bo_get_stride name. For compatibility with previous version of libgbm we now explicitly check the version of libgbm in configure.ac and expose COGL_GBM_{MAJOR,MINOR,MICRO} defines to the code so we can conditionally use the older gbm_bo_get_pitch() name with older versions. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 47c6247095e2f1f8725c4eb08d38c9de15e283cd)
2012-08-07 13:56:45 +00:00
uint32_t handle, stride;
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
CoglFlipKMS *flip;
GList *l;
egl-kms: Use drmModePageFlip The KMS platform now uses drmModePageFlip to present the buffer. The main loop mechanism is used to poll for events on the DRM file descriptor so that we notice when the page flip is complete. The swap_buffers is throttled so that if there is a pending flip it will block until it is complete before starting another flip. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 17:17:28 +00:00
/* If we already have a pending swap then block until it completes */
while (kms_onscreen->next_fb_id != 0)
handle_drm_event (kms_renderer);
kms: Use GBM surfaces Instead of creating FBOs on the GL side, the KMS EGL platform uses the latest changes to Mesa to create an EGL surface using a GBM surface as the native surface type. This removes some of the special vtable hooks that the KMS platform needed because it is now much more similar to the other platforms. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 15:37:26 +00:00
onscreen: Adds swap_buffers_with_damage api This adds api to be able requests a swap_buffers and also pass a list of damage rectangles that can be passed on to a compositor to enable it to minimize how much of the screen it needs to recompose. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 0d9684c7b7c2018bb42715c369555330d38514a2)
2012-02-07 17:59:51 +00:00
parent_vtable->onscreen_swap_buffers_with_damage (onscreen,
rectangles,
n_rectangles);
kms: Use GBM surfaces Instead of creating FBOs on the GL side, the KMS EGL platform uses the latest changes to Mesa to create an EGL surface using a GBM surface as the native surface type. This removes some of the special vtable hooks that the KMS platform needed because it is now much more similar to the other platforms. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 15:37:26 +00:00
/* Now we need to set the CRTC to whatever is the front buffer */
egl-kms: Use drmModePageFlip The KMS platform now uses drmModePageFlip to present the buffer. The main loop mechanism is used to poll for events on the DRM file descriptor so that we notice when the page flip is complete. The swap_buffers is throttled so that if there is a pending flip it will block until it is complete before starting another flip. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 17:17:28 +00:00
kms_onscreen->next_bo = gbm_surface_lock_front_buffer (kms_onscreen->surface);
kms: Use GBM surfaces Instead of creating FBOs on the GL side, the KMS EGL platform uses the latest changes to Mesa to create an EGL surface using a GBM surface as the native surface type. This removes some of the special vtable hooks that the KMS platform needed because it is now much more similar to the other platforms. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 15:37:26 +00:00
kms: Fix the version check for GBM The check for whether to use ‘stride’ instead of ‘pitch’ from the GBM API tries to check whether the GBM version is >= 8.1.0. However it was comparing the major and micro components independently so any version with the minor part set to 0 would fail. The GBM version in Mesa master is now 9.0.0 which breaks it. This patch changes it to check the version using the COGL_VERSION_ENCODE macro instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 38f1dc58b35023f9e6bbc0db746b1554bd0377fc)
2012-09-06 16:33:20 +00:00
#if (COGL_VERSION_ENCODE (COGL_GBM_MAJOR, COGL_GBM_MINOR, COGL_GBM_MICRO) >= \
COGL_VERSION_ENCODE (8, 1, 0))
kms: Update to latest gbm api gbm_bo_get_pitch was renamed to gbm_bo_get_stride to be consistent with how the terms pitch and stride are used throughout mesa. This updates the Cogl backend to use the new gbm_bo_get_stride name. For compatibility with previous version of libgbm we now explicitly check the version of libgbm in configure.ac and expose COGL_GBM_{MAJOR,MINOR,MICRO} defines to the code so we can conditionally use the older gbm_bo_get_pitch() name with older versions. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 47c6247095e2f1f8725c4eb08d38c9de15e283cd)
2012-08-07 13:56:45 +00:00
stride = gbm_bo_get_stride (kms_onscreen->next_bo);
#else
stride = gbm_bo_get_pitch (kms_onscreen->next_bo);
#endif
egl-kms: Use drmModePageFlip The KMS platform now uses drmModePageFlip to present the buffer. The main loop mechanism is used to poll for events on the DRM file descriptor so that we notice when the page flip is complete. The swap_buffers is throttled so that if there is a pending flip it will block until it is complete before starting another flip. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 17:17:28 +00:00
handle = gbm_bo_get_handle (kms_onscreen->next_bo).u32;
kms: Use GBM surfaces Instead of creating FBOs on the GL side, the KMS EGL platform uses the latest changes to Mesa to create an EGL surface using a GBM surface as the native surface type. This removes some of the special vtable hooks that the KMS platform needed because it is now much more similar to the other platforms. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 15:37:26 +00:00
if (drmModeAddFB (kms_renderer->fd,
kms_display->width,
kms_display->height,
24, /* depth */
32, /* bpp */
kms: Update to latest gbm api gbm_bo_get_pitch was renamed to gbm_bo_get_stride to be consistent with how the terms pitch and stride are used throughout mesa. This updates the Cogl backend to use the new gbm_bo_get_stride name. For compatibility with previous version of libgbm we now explicitly check the version of libgbm in configure.ac and expose COGL_GBM_{MAJOR,MINOR,MICRO} defines to the code so we can conditionally use the older gbm_bo_get_pitch() name with older versions. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 47c6247095e2f1f8725c4eb08d38c9de15e283cd)
2012-08-07 13:56:45 +00:00
stride,
kms: Use GBM surfaces Instead of creating FBOs on the GL side, the KMS EGL platform uses the latest changes to Mesa to create an EGL surface using a GBM surface as the native surface type. This removes some of the special vtable hooks that the KMS platform needed because it is now much more similar to the other platforms. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 15:37:26 +00:00
handle,
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
&kms_onscreen->next_fb_id))
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
{
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
g_warning ("Failed to create new back buffer handle: %m");
gbm_surface_release_buffer (kms_onscreen->surface,
kms_onscreen->next_bo);
kms_onscreen->next_bo = NULL;
kms_onscreen->next_fb_id = 0;
return;
egl-kms: Use drmModePageFlip The KMS platform now uses drmModePageFlip to present the buffer. The main loop mechanism is used to poll for events on the DRM file descriptor so that we notice when the page flip is complete. The swap_buffers is throttled so that if there is a pending flip it will block until it is complete before starting another flip. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 17:17:28 +00:00
}
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
kms: defer setting crtc modes until first swap buffers Instead of creating a dummy framebuffer allocation just so we can setup crtc modes during display_setup we now wait until the first swap_buffers request before setting up the crtc modes. This patch also adds a cogl_kms_display_queue_modes_reset() function that allows developers to explicitly queue a reset of the crtc modes. The idea is that applications that handle VT switching can use this for VT enter events to explicitly ensure their mode is restored since modes are often not automatically restored correctly. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-30 11:06:41 +00:00
/* If this is the first framebuffer to be presented then we now setup the
* crtc modes... */
if (kms_display->pending_set_crtc)
{
setup_crtc_modes (context->display, kms_onscreen->next_fb_id);
kms_display->pending_set_crtc = FALSE;
}
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
flip = g_slice_new0 (CoglFlipKMS);
flip->onscreen = onscreen;
for (l = kms_display->outputs; l; l = l->next)
egl-kms: Use drmModePageFlip The KMS platform now uses drmModePageFlip to present the buffer. The main loop mechanism is used to poll for events on the DRM file descriptor so that we notice when the page flip is complete. The swap_buffers is throttled so that if there is a pending flip it will block until it is complete before starting another flip. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 17:17:28 +00:00
{
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
CoglOutputKMS *output = l->data;
if (drmModePageFlip (kms_renderer->fd,
output->encoder->crtc_id,
kms_onscreen->next_fb_id,
DRM_MODE_PAGE_FLIP_EVENT,
flip))
{
g_warning ("Failed to flip: %m");
continue;
}
flip->pending++;
}
if (flip->pending == 0)
{
drmModeRmFB (kms_renderer->fd, kms_onscreen->next_fb_id);
egl-kms: Use drmModePageFlip The KMS platform now uses drmModePageFlip to present the buffer. The main loop mechanism is used to poll for events on the DRM file descriptor so that we notice when the page flip is complete. The swap_buffers is throttled so that if there is a pending flip it will block until it is complete before starting another flip. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 17:17:28 +00:00
gbm_surface_release_buffer (kms_onscreen->surface,
kms_onscreen->next_bo);
kms_onscreen->next_bo = NULL;
kms_onscreen->next_fb_id = 0;
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
g_slice_free (CoglFlipKMS, flip);
flip = NULL;
}
else
{
/* Ensure the onscreen remains valid while it has any pending flips... */
cogl_object_ref (flip->onscreen);
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
}
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
static CoglBool
kms: Implement the swap buffers notify feature The KMS EGL platform now notifies when a swap is complete. The notification is delayed until the application calls cogl_context_dispatch. The GLX backend doesn't currently do this but I think that is how it should behave to make it easier for the application to handle locks and such. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 19:28:30 +00:00
_cogl_winsys_egl_context_init (CoglContext *context,
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
CoglError **error)
kms: Implement the swap buffers notify feature The KMS EGL platform now notifies when a swap is complete. The notification is delayed until the application calls cogl_context_dispatch. The GLX backend doesn't currently do this but I think that is how it should behave to make it easier for the application to handle locks and such. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 19:28:30 +00:00
{
COGL_FLAGS_SET (context->features,
COGL_FEATURE_ID_SWAP_BUFFERS_EVENT, TRUE);
onscreen: Add CoglFrameInfo and _add_frame_callback() api Add a CoglFrameInfo object that tracks timing information for frames that are drawn. We track a frame counter and frame timing information for each CoglOnscreen. Internally a CoglFrameInfo is automatically created for each frame, delimited by cogl_onscreen_swap_buffers() or cogl_onscreen_swap_region() calls. CoglFrameInfos are delivered to applications via frame event callbacks that can be registered with a new cogl_onscreen_add_frame_callback() api. Two initial event types (dispatched on all platforms) have been defined; a _SYNC event used for throttling the frame rate of applications and a _COMPLETE event used so signify the end of a frame. Note: This new _add_frame_callback() api makes the cogl_onscreen_add_swap_complete_callback() api redundant and so it should be considered deprecated. Since the _add_swap_complete_callback() api is still experimental api, we will be looking to quickly migrate users to the new api so we can remove the old api. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 700401667db2522045e4623d78797b17f9184501)
2012-11-12 16:58:10 +00:00
/* TODO: remove this deprecated feature */
kms: Implement the swap buffers notify feature The KMS EGL platform now notifies when a swap is complete. The notification is delayed until the application calls cogl_context_dispatch. The GLX backend doesn't currently do this but I think that is how it should behave to make it easier for the application to handle locks and such. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 19:28:30 +00:00
COGL_FLAGS_SET (context->winsys_features,
COGL_WINSYS_FEATURE_SWAP_BUFFERS_EVENT,
TRUE);
onscreen: Add CoglFrameInfo and _add_frame_callback() api Add a CoglFrameInfo object that tracks timing information for frames that are drawn. We track a frame counter and frame timing information for each CoglOnscreen. Internally a CoglFrameInfo is automatically created for each frame, delimited by cogl_onscreen_swap_buffers() or cogl_onscreen_swap_region() calls. CoglFrameInfos are delivered to applications via frame event callbacks that can be registered with a new cogl_onscreen_add_frame_callback() api. Two initial event types (dispatched on all platforms) have been defined; a _SYNC event used for throttling the frame rate of applications and a _COMPLETE event used so signify the end of a frame. Note: This new _add_frame_callback() api makes the cogl_onscreen_add_swap_complete_callback() api redundant and so it should be considered deprecated. Since the _add_swap_complete_callback() api is still experimental api, we will be looking to quickly migrate users to the new api so we can remove the old api. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 700401667db2522045e4623d78797b17f9184501)
2012-11-12 16:58:10 +00:00
COGL_FLAGS_SET (context->winsys_features,
COGL_WINSYS_FEATURE_SYNC_AND_COMPLETE_EVENT,
TRUE);
kms: Implement the swap buffers notify feature The KMS EGL platform now notifies when a swap is complete. The notification is delayed until the application calls cogl_context_dispatch. The GLX backend doesn't currently do this but I think that is how it should behave to make it easier for the application to handle locks and such. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 19:28:30 +00:00
return TRUE;
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
static CoglBool
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
_cogl_winsys_onscreen_init (CoglOnscreen *onscreen,
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
CoglError **error)
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
{
CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
CoglContext *context = framebuffer->context;
CoglDisplay *display = context->display;
CoglDisplayEGL *egl_display = display->winsys;
CoglDisplayKMS *kms_display = egl_display->platform;
CoglRenderer *renderer = display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglRendererKMS *kms_renderer = egl_renderer->platform;
CoglOnscreenEGL *egl_onscreen;
CoglOnscreenKMS *kms_onscreen;
_COGL_RETURN_VAL_IF_FAIL (egl_display->egl_context, FALSE);
onscreen->winsys = g_slice_new0 (CoglOnscreenEGL);
egl_onscreen = onscreen->winsys;
kms_onscreen = g_slice_new0 (CoglOnscreenKMS);
egl_onscreen->platform = kms_onscreen;
kms: Use GBM surfaces Instead of creating FBOs on the GL side, the KMS EGL platform uses the latest changes to Mesa to create an EGL surface using a GBM surface as the native surface type. This removes some of the special vtable hooks that the KMS platform needed because it is now much more similar to the other platforms. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 15:37:26 +00:00
kms_onscreen->surface =
gbm_surface_create (kms_renderer->gbm,
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
kms_display->width,
kms_display->height,
kms: Use GBM surfaces Instead of creating FBOs on the GL side, the KMS EGL platform uses the latest changes to Mesa to create an EGL surface using a GBM surface as the native surface type. This removes some of the special vtable hooks that the KMS platform needed because it is now much more similar to the other platforms. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 15:37:26 +00:00
GBM_BO_FORMAT_XRGB8888,
GBM_BO_USE_SCANOUT |
GBM_BO_USE_RENDERING);
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
kms: Use GBM surfaces Instead of creating FBOs on the GL side, the KMS EGL platform uses the latest changes to Mesa to create an EGL surface using a GBM surface as the native surface type. This removes some of the special vtable hooks that the KMS platform needed because it is now much more similar to the other platforms. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 15:37:26 +00:00
if (!kms_onscreen->surface)
{
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
_cogl_set_error (error, COGL_WINSYS_ERROR,
kms: Use GBM surfaces Instead of creating FBOs on the GL side, the KMS EGL platform uses the latest changes to Mesa to create an EGL surface using a GBM surface as the native surface type. This removes some of the special vtable hooks that the KMS platform needed because it is now much more similar to the other platforms. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 15:37:26 +00:00
COGL_WINSYS_ERROR_CREATE_ONSCREEN,
"Failed to allocate surface");
return FALSE;
}
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
kms: Use GBM surfaces Instead of creating FBOs on the GL side, the KMS EGL platform uses the latest changes to Mesa to create an EGL surface using a GBM surface as the native surface type. This removes some of the special vtable hooks that the KMS platform needed because it is now much more similar to the other platforms. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 15:37:26 +00:00
egl_onscreen->egl_surface =
eglCreateWindowSurface (egl_renderer->edpy,
egl_display->egl_config,
(NativeWindowType) kms_onscreen->surface,
NULL);
if (egl_onscreen->egl_surface == EGL_NO_SURFACE)
{
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
_cogl_set_error (error, COGL_WINSYS_ERROR,
kms: Use GBM surfaces Instead of creating FBOs on the GL side, the KMS EGL platform uses the latest changes to Mesa to create an EGL surface using a GBM surface as the native surface type. This removes some of the special vtable hooks that the KMS platform needed because it is now much more similar to the other platforms. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 15:37:26 +00:00
COGL_WINSYS_ERROR_CREATE_ONSCREEN,
"Failed to allocate surface");
return FALSE;
}
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
_cogl_framebuffer_winsys_update_size (framebuffer,
kms: Don't use egl_surface_width/height The egl_surface_width/height properties in CoglDisplayEGL were accidentally being conditionally defined depending on KMS support. They are not necessary because CoglDisplayKMS also already stores the width/height and this was just copied over to the EGL dipslay. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 21:17:33 +00:00
kms_display->width,
kms_display->height);
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
return TRUE;
}
static void
_cogl_winsys_onscreen_deinit (CoglOnscreen *onscreen)
{
CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
CoglContext *context = framebuffer->context;
CoglRenderer *renderer = context->display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglOnscreenKMS *kms_onscreen;
/* If we never successfully allocated then there's nothing to do */
if (egl_onscreen == NULL)
return;
kms_onscreen = egl_onscreen->platform;
kms: Add mirror support and env var configurability This adds support for mirroring the display output on two KMS connectors. This patch also checks for a number of environment variables that can influence how KMS is configured. The following variables can be set: COGL_KMS_MIRROR: If this is set to anything then Cogl will try and setup two connectors with the same resolution so that onscreen frame buffers can be mirrored. COGL_KMS_CONNECTOR0: This can be set to an integer identifier for a specific KMS connector id to use for the first output. COGL_KMS_CONNECTOR0_MODE: Can be set to a mode name like "1024x768" explicitly select what mode should be used for the first output. If COGL_KMS_MIRROR is set then COGL_KMS_CONNECTOR1 and COGL_KMS_CONNECTOR1_MODE can optionally be set to specify a connector id and mode name for the second output. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-25 19:29:29 +00:00
/* flip state takes a reference on the onscreen so there should
* never be outstanding flips when we reach here. */
g_return_if_fail (kms_onscreen->next_fb_id == 0);
kms: Implement the swap buffers notify feature The KMS EGL platform now notifies when a swap is complete. The notification is delayed until the application calls cogl_context_dispatch. The GLX backend doesn't currently do this but I think that is how it should behave to make it easier for the application to handle locks and such. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 19:28:30 +00:00
free_current_bo (onscreen);
kms: Use GBM surfaces Instead of creating FBOs on the GL side, the KMS EGL platform uses the latest changes to Mesa to create an EGL surface using a GBM surface as the native surface type. This removes some of the special vtable hooks that the KMS platform needed because it is now much more similar to the other platforms. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 15:37:26 +00:00
if (egl_onscreen->egl_surface != EGL_NO_SURFACE)
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
{
kms: Use GBM surfaces Instead of creating FBOs on the GL side, the KMS EGL platform uses the latest changes to Mesa to create an EGL surface using a GBM surface as the native surface type. This removes some of the special vtable hooks that the KMS platform needed because it is now much more similar to the other platforms. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 15:37:26 +00:00
eglDestroySurface (egl_renderer->edpy, egl_onscreen->egl_surface);
egl_onscreen->egl_surface = EGL_NO_SURFACE;
}
if (kms_onscreen->surface)
{
gbm_surface_destroy (kms_onscreen->surface);
kms_onscreen->surface = NULL;
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
}
g_slice_free (CoglOnscreenKMS, kms_onscreen);
g_slice_free (CoglOnscreenEGL, onscreen->winsys);
onscreen->winsys = NULL;
}
static const CoglWinsysEGLVtable
_cogl_winsys_egl_vtable =
{
.display_setup = _cogl_winsys_egl_display_setup,
.display_destroy = _cogl_winsys_egl_display_destroy,
kms: Use GBM surfaces Instead of creating FBOs on the GL side, the KMS EGL platform uses the latest changes to Mesa to create an EGL surface using a GBM surface as the native surface type. This removes some of the special vtable hooks that the KMS platform needed because it is now much more similar to the other platforms. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 15:37:26 +00:00
.context_created = _cogl_winsys_egl_context_created,
kms: Implement the swap buffers notify feature The KMS EGL platform now notifies when a swap is complete. The notification is delayed until the application calls cogl_context_dispatch. The GLX backend doesn't currently do this but I think that is how it should behave to make it easier for the application to handle locks and such. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 19:28:30 +00:00
.cleanup_context = _cogl_winsys_egl_cleanup_context,
.context_init = _cogl_winsys_egl_context_init
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
};
Add a separate winsys vtable for each EGL platform Instead of just having an "EGL" renderer, there is now a separate winsys for each platform. Currently they just directly copy the vtable for the EGL platform so it is still only possible to have one EGL platform compiled into Cogl. However the intention is that the winsys-specific code for each platform will be moved into override functions in the corresponding platform winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-08 17:24:40 +00:00
const CoglWinsysVtable *
_cogl_winsys_egl_kms_get_vtable (void)
{
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
static CoglBool vtable_inited = FALSE;
Add a separate winsys vtable for each EGL platform Instead of just having an "EGL" renderer, there is now a separate winsys for each platform. Currently they just directly copy the vtable for the EGL platform so it is still only possible to have one EGL platform compiled into Cogl. However the intention is that the winsys-specific code for each platform will be moved into override functions in the corresponding platform winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-08 17:24:40 +00:00
static CoglWinsysVtable vtable;
if (!vtable_inited)
{
/* The EGL_KMS winsys is a subclass of the EGL winsys so we
start by copying its vtable */
kms: Use GBM surfaces Instead of creating FBOs on the GL side, the KMS EGL platform uses the latest changes to Mesa to create an EGL surface using a GBM surface as the native surface type. This removes some of the special vtable hooks that the KMS platform needed because it is now much more similar to the other platforms. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 15:37:26 +00:00
parent_vtable = _cogl_winsys_egl_get_vtable ();
vtable = *parent_vtable;
Add a separate winsys vtable for each EGL platform Instead of just having an "EGL" renderer, there is now a separate winsys for each platform. Currently they just directly copy the vtable for the EGL platform so it is still only possible to have one EGL platform compiled into Cogl. However the intention is that the winsys-specific code for each platform will be moved into override functions in the corresponding platform winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-08 17:24:40 +00:00
vtable.id = COGL_WINSYS_ID_EGL_KMS;
vtable.name = "EGL_KMS";
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
vtable.renderer_connect = _cogl_winsys_renderer_connect;
vtable.renderer_disconnect = _cogl_winsys_renderer_disconnect;
vtable.onscreen_init = _cogl_winsys_onscreen_init;
vtable.onscreen_deinit = _cogl_winsys_onscreen_deinit;
/* The KMS winsys doesn't support swap region */
vtable.onscreen_swap_region = NULL;
onscreen: Adds swap_buffers_with_damage api This adds api to be able requests a swap_buffers and also pass a list of damage rectangles that can be passed on to a compositor to enable it to minimize how much of the screen it needs to recompose. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 0d9684c7b7c2018bb42715c369555330d38514a2)
2012-02-07 17:59:51 +00:00
vtable.onscreen_swap_buffers_with_damage =
_cogl_winsys_onscreen_swap_buffers_with_damage;
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
Add a separate winsys vtable for each EGL platform Instead of just having an "EGL" renderer, there is now a separate winsys for each platform. Currently they just directly copy the vtable for the EGL platform so it is still only possible to have one EGL platform compiled into Cogl. However the intention is that the winsys-specific code for each platform will be moved into override functions in the corresponding platform winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-08 17:24:40 +00:00
vtable_inited = TRUE;
}
return &vtable;
}
kms: Adds api to get at the kms file descriptor This adds a cogl_kms_renderer_get_kms_fd() function that lets developers access the kms file descriptor being used for controlling the kernel mode setting. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-23 15:37:51 +00:00
int
cogl_kms_renderer_get_kms_fd (CoglRenderer *renderer)
{
_COGL_RETURN_VAL_IF_FAIL (cogl_is_renderer (renderer), -1);
if (renderer->connected)
{
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglRendererKMS *kms_renderer = egl_renderer->platform;
return kms_renderer->fd;
}
else
return -1;
}
kms: defer setting crtc modes until first swap buffers Instead of creating a dummy framebuffer allocation just so we can setup crtc modes during display_setup we now wait until the first swap_buffers request before setting up the crtc modes. This patch also adds a cogl_kms_display_queue_modes_reset() function that allows developers to explicitly queue a reset of the crtc modes. The idea is that applications that handle VT switching can use this for VT enter events to explicitly ensure their mode is restored since modes are often not automatically restored correctly. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-30 11:06:41 +00:00
void
cogl_kms_display_queue_modes_reset (CoglDisplay *display)
{
if (display->setup)
{
CoglDisplayEGL *egl_display = display->winsys;
CoglDisplayKMS *kms_display = egl_display->platform;
kms_display->pending_set_crtc = TRUE;
}
}
Copy permalink