From 1a4b7ee28bf7413af6513fb45ad0d0736048f866 Mon Sep 17 00:00:00 2001 From: Brad Bishop Date: Sun, 16 Dec 2018 17:11:34 -0800 Subject: reset upstream subtrees to yocto 2.6 Reset the following subtrees on thud HEAD: poky: 87e3a9739d meta-openembedded: 6094ae18c8 meta-security: 31dc4e7532 meta-raspberrypi: a48743dc36 meta-xilinx: c42016e2e6 Also re-apply backports that didn't make it into thud: poky: 17726d0 systemd-systemctl-native: handle Install wildcards meta-openembedded: 4321a5d libtinyxml2: update to 7.0.1 042f0a3 libcereal: Add native and nativesdk classes e23284f libcereal: Allow empty package 030e8d4 rsyslog: curl-less build with fmhttp PACKAGECONFIG 179a1b9 gtest: update to 1.8.1 Squashed OpenBMC subtree compatibility updates: meta-aspeed: Brad Bishop (1): aspeed: add yocto 2.6 compatibility meta-ibm: Brad Bishop (1): ibm: prepare for yocto 2.6 meta-ingrasys: Brad Bishop (1): ingrasys: set layer compatibility to yocto 2.6 meta-openpower: Brad Bishop (1): openpower: set layer compatibility to yocto 2.6 meta-phosphor: Brad Bishop (3): phosphor: set layer compatibility to thud phosphor: libgpg-error: drop patches phosphor: react to fitimage artifact rename Ed Tanous (4): Dropbear: upgrade options for latest upgrade yocto2.6: update openssl options busybox: remove upstream watchdog patch systemd: Rebase CONFIG_CGROUP_BPF patch Change-Id: I7b1fe71cca880d0372a82d94b5fd785323e3a9e7 Signed-off-by: Brad Bishop --- ...ayland-Add-support-for-the-Wayland-winsys.patch | 1898 ++++++++++++++++++++ 1 file changed, 1898 insertions(+) create mode 100644 meta-raspberrypi/recipes-graphics/userland/files/0002-wayland-Add-support-for-the-Wayland-winsys.patch (limited to 'meta-raspberrypi/recipes-graphics/userland/files/0002-wayland-Add-support-for-the-Wayland-winsys.patch') diff --git a/meta-raspberrypi/recipes-graphics/userland/files/0002-wayland-Add-support-for-the-Wayland-winsys.patch b/meta-raspberrypi/recipes-graphics/userland/files/0002-wayland-Add-support-for-the-Wayland-winsys.patch new file mode 100644 index 000000000..c41cde779 --- /dev/null +++ b/meta-raspberrypi/recipes-graphics/userland/files/0002-wayland-Add-support-for-the-Wayland-winsys.patch @@ -0,0 +1,1898 @@ +From da60a2a34a48e2b324fceae608964814488cc8fb Mon Sep 17 00:00:00 2001 +From: Tomeu Vizoso +Date: Tue, 1 Oct 2013 13:19:20 +0200 +Subject: [PATCH 02/18] wayland: Add support for the Wayland winsys + +* Adds EGL_WL_bind_wayland_display extension +* Adds wayland-egl library +* Adds wl_dispmanx_buffer protocol extension + +TODO: Check that platform_get_dimensions() returning swapchain_count == 1 is correct + +TODO: Remove the requirement of passing a valid DispmanX element handle to +the SwapBuffers and CreateSurface RPC calls. This will remove the need to open +a DispmanX display from the clients. + +TODO: wl_dispmanx_server_buffer should probably be defined in a +private header that can be included from EGL and vc_* instead of in +vc_vchi_dispmanx.h + +Signed-off-by: Khem Raj +--- + .gitignore | 1 + + CMakeLists.txt | 11 + + README.md | 4 + + buildme | 10 +- + .../linux/apps/raspicam/CMakeLists.txt | 2 +- + interface/khronos/CMakeLists.txt | 54 +++- + interface/khronos/common/khrn_client.c | 15 ++ + interface/khronos/common/khrn_client.h | 10 + + interface/khronos/common/khrn_client_mangle.h | 3 + + .../khronos/common/khrn_client_platform.h | 8 + + .../khronos/common/khrn_client_unmangle.h | 3 + + .../common/linux/khrn_client_platform_linux.c | 115 +++++++- + interface/khronos/common/linux/khrn_wayland.c | 215 +++++++++++++++ + .../common/linux/khrn_wayland.h} | 46 +--- + interface/khronos/egl/egl_client.c | 92 +++++-- + interface/khronos/egl/egl_client_get_proc.c | 11 + + interface/khronos/egl/egl_client_surface.c | 42 ++- + interface/khronos/egl/egl_client_surface.h | 38 ++- + interface/khronos/egl/egl_int_impl.h | 2 +- + interface/khronos/ext/egl_wayland.c | 246 ++++++++++++++++++ + interface/khronos/include/EGL/eglext.h | 23 ++ + .../khronos/wayland-egl/wayland-egl-priv.h | 53 ++++ + interface/khronos/wayland-egl/wayland-egl.c | 59 +++++ + .../khronos/wayland-egl/wayland-egl.pc.in | 10 + + interface/vmcs_host/CMakeLists.txt | 21 +- + interface/vmcs_host/vc_dispmanx.h | 10 + + interface/vmcs_host/vc_vchi_dispmanx.c | 42 +++ + interface/vmcs_host/vc_vchi_dispmanx.h | 15 ++ + interface/wayland/dispmanx.xml | 123 +++++++++ + makefiles/cmake/Wayland.cmake | 72 +++++ + 30 files changed, 1257 insertions(+), 99 deletions(-) + create mode 100644 interface/khronos/common/linux/khrn_wayland.c + copy interface/{vmcs_host/vc_vchi_dispmanx.h => khronos/common/linux/khrn_wayland.h} (56%) + create mode 100644 interface/khronos/ext/egl_wayland.c + create mode 100644 interface/khronos/wayland-egl/wayland-egl-priv.h + create mode 100644 interface/khronos/wayland-egl/wayland-egl.c + create mode 100644 interface/khronos/wayland-egl/wayland-egl.pc.in + create mode 100644 interface/wayland/dispmanx.xml + create mode 100644 makefiles/cmake/Wayland.cmake + +diff --git a/.gitignore b/.gitignore +index 63570f1..1459436 100644 +--- a/.gitignore ++++ b/.gitignore +@@ -30,3 +30,4 @@ build/ + *.pts + *.ppm + *.mkv ++*~ +diff --git a/CMakeLists.txt b/CMakeLists.txt +index cfc8ae5..673a5ad 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -24,6 +24,17 @@ include(makefiles/cmake/global_settings.cmake) + include(makefiles/cmake/arm-linux.cmake) + include(makefiles/cmake/vmcs.cmake) + ++if (BUILD_WAYLAND) ++ include(makefiles/cmake/Wayland.cmake) ++ ++ # Find Wayland libraries ++ find_package(PkgConfig) ++ pkg_check_modules(WAYLAND_CLIENT wayland-client REQUIRED) ++ pkg_check_modules(WAYLAND_SERVER wayland-server REQUIRED) ++ ++ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DBUILD_WAYLAND") ++endif() ++ + enable_language(ASM) + + # Global include paths +diff --git a/README.md b/README.md +index 94b93b8..50b90b1 100644 +--- a/README.md ++++ b/README.md +@@ -6,3 +6,7 @@ Use buildme to build. It requires cmake to be installed and an arm cross compile + https://github.com/raspberrypi/tools/tree/master/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian + + Note that this repository does not contain the source for the edid_parser and vcdbg binaries due to licensing restrictions. ++ ++To build support for the Wayland winsys in EGL, execute the buildme script like this: ++ ++$ BUILD_WAYLAND=1 ./buildme. +diff --git a/buildme b/buildme +index b8fd440..a780bb6 100755 +--- a/buildme ++++ b/buildme +@@ -8,6 +8,10 @@ fi + + BUILDSUBDIR=`echo $BUILDTYPE | tr '[A-Z]' '[a-z]'`; + ++if [ -n "$BUILD_WAYLAND" ]; then ++ WAYLAND_VARS="-DBUILD_WAYLAND=TRUE" ++fi ++ + if [ "armv6l" = `arch` ] || [ "armv7l" = `arch` ]; then + # Native compile on the Raspberry Pi + mkdir -p build/raspberry/$BUILDSUBDIR +@@ -32,9 +36,13 @@ elif [ "$1" = "--native" ]; then + make -j `nproc` $* + else + # Cross compile on a more capable machine ++ if [ -n "$BUILD_WAYLAND" ]; then ++ # Use wayland-scanner from the build platform ++ WAYLAND_VARS+=" -DWAYLAND_SCANNER_EXECUTABLE:FILEPATH=/usr/bin/wayland-scanner" ++ fi + mkdir -p build/arm-linux/$BUILDSUBDIR + pushd build/arm-linux/$BUILDSUBDIR +- cmake -DCMAKE_TOOLCHAIN_FILE=../../../makefiles/cmake/toolchains/arm-linux-gnueabihf.cmake -DCMAKE_BUILD_TYPE=$BUILDTYPE ../../.. ++ cmake -DCMAKE_TOOLCHAIN_FILE=../../../makefiles/cmake/toolchains/arm-linux-gnueabihf.cmake -DCMAKE_BUILD_TYPE=$BUILDTYPE $WAYLAND_VARS ../../.. + make -j `nproc` + + if [ "$1" != "" ]; then +diff --git a/host_applications/linux/apps/raspicam/CMakeLists.txt b/host_applications/linux/apps/raspicam/CMakeLists.txt +index 42636e8..d47ad55 100644 +--- a/host_applications/linux/apps/raspicam/CMakeLists.txt ++++ b/host_applications/linux/apps/raspicam/CMakeLists.txt +@@ -33,7 +33,7 @@ add_executable(raspividyuv ${COMMON_SOURCES} RaspiVidYUV.c) + + set (MMAL_LIBS mmal_core mmal_util mmal_vc_client) + +-target_link_libraries(raspistill ${MMAL_LIBS} vcos bcm_host brcmGLESv2 brcmEGL m dl) ++target_link_libraries(raspistill ${MMAL_LIBS} vcos bcm_host brcmGLESv2 brcmEGL m dl ${WAYLAND_SERVER_LIBRARIES} ${WAYLAND_CLIENT_LIBRARIES}) + target_link_libraries(raspiyuv ${MMAL_LIBS} vcos bcm_host) + target_link_libraries(raspivid ${MMAL_LIBS} vcos bcm_host) + target_link_libraries(raspividyuv ${MMAL_LIBS} vcos bcm_host) +diff --git a/interface/khronos/CMakeLists.txt b/interface/khronos/CMakeLists.txt +index 9ad615b..95c0e11 100644 +--- a/interface/khronos/CMakeLists.txt ++++ b/interface/khronos/CMakeLists.txt +@@ -6,6 +6,12 @@ + # have quite a few circular dependencies, and so the only way + # to make it work seems to be to have everything static. + ++if (BUILD_WAYLAND) ++include_directories( ++ ${WAYLAND_SERVER_INCLUDE_DIRS} ++) ++endif () ++ + set(EGL_SOURCE + egl/egl_client_config.c + egl/egl_client_context.c +@@ -55,12 +61,55 @@ set(CLIENT_SOURCE + common/khrn_int_hash_asm.s + common/khrn_client_cache.c) + ++set(EGL_LIBS ++ khrn_client ++ vchiq_arm ++ vcos ++ bcm_host) ++ ++if (BUILD_WAYLAND) ++ set(EGL_SOURCE ++ ${EGL_SOURCE} ++ ext/egl_wayland.c ++ common/linux/khrn_wayland.c) ++ ++ set(EGL_LIBS ++ ${EGL_LIBS} ++ wayland-client ++ wayland-server) ++ ++ set(WAYLAND_EGL_SOURCE ++ wayland-egl/wayland-egl.c) ++ ++ wayland_add_protocol_server( ++ EGL_SOURCE ++ ../../interface/wayland/dispmanx.xml ++ dispmanx ++ ) ++ ++ wayland_add_protocol_client( ++ EGL_SOURCE ++ ../../interface/wayland/dispmanx.xml ++ dispmanx ++ ) ++ ++ add_library(wayland-egl ${SHARED} ${WAYLAND_EGL_SOURCE}) ++ install(TARGETS wayland-egl DESTINATION lib) ++ ++ configure_file ("wayland-egl/wayland-egl.pc.in" "wayland-egl/wayland-egl.pc" @ONLY) ++ install (FILES "${CMAKE_CURRENT_BINARY_DIR}/wayland-egl/wayland-egl.pc" ++ DESTINATION lib/pkgconfig) ++endif () ++ + add_library(EGL ${SHARED} ${EGL_SOURCE}) + add_library(GLESv2 ${SHARED} ${GLES_SOURCE}) + add_library(OpenVG ${SHARED} ${VG_SOURCE}) + add_library(WFC ${SHARED} ${WFC_SOURCE}) + add_library(khrn_client ${CLIENT_SOURCE}) + ++set_target_properties(EGL PROPERTIES SOVERSION 1 VERSION 1.0.0) ++set_target_properties(GLESv2 PROPERTIES SOVERSION 2 VERSION 2.0.0) ++ + # TODO do we need EGL_static and GLESv2_static now that khrn_static exists? + add_library(EGL_static STATIC ${EGL_SOURCE}) + add_library(GLESv2_static STATIC ${GLES_SOURCE}) +@@ -72,8 +121,7 @@ include_directories (../../host_applications/linux/libs/sm ) + set(VCSM_LIBS vcsm) + add_definitions(-DKHRONOS_HAVE_VCSM) + endif() +- +-target_link_libraries(EGL khrn_client vchiq_arm vcos bcm_host ${VCSM_LIBS} -lm) ++target_link_libraries(EGL ${EGL_LIBS} ${VCSM_LIBS} -lm) + target_link_libraries(GLESv2 EGL khrn_client vcos) + target_link_libraries(WFC EGL) + target_link_libraries(OpenVG EGL) +@@ -87,7 +135,7 @@ add_library(brcmGLESv2 ${SHARED} ${GLES_SOURCE}) + add_library(brcmOpenVG ${SHARED} ${VG_SOURCE}) + add_library(brcmWFC ${SHARED} ${WFC_SOURCE}) + +-target_link_libraries(brcmEGL khrn_client vchiq_arm vcos bcm_host ${VCSM_LIBS} -lm) ++target_link_libraries(brcmEGL ${EGL_LIBS} ${VCSM_LIBS} -lm) + target_link_libraries(brcmGLESv2 brcmEGL khrn_client vcos) + target_link_libraries(brcmWFC brcmEGL) + target_link_libraries(brcmOpenVG brcmEGL) +diff --git a/interface/khronos/common/khrn_client.c b/interface/khronos/common/khrn_client.c +index ef4babd..d7e798e 100644 +--- a/interface/khronos/common/khrn_client.c ++++ b/interface/khronos/common/khrn_client.c +@@ -54,6 +54,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + #include "applications/vmcs/khronos/khronos_server.h" + #endif + ++#ifdef BUILD_WAYLAND ++#include "interface/khronos/common/linux/khrn_wayland.h" ++#endif ++ + VCOS_LOG_CAT_T khrn_client_log = VCOS_LOG_INIT("khrn_client", VCOS_LOG_WARN); + + /* +@@ -142,6 +146,10 @@ void client_try_unload_server(CLIENT_PROCESS_STATE_T *process) + bool client_process_state_init(CLIENT_PROCESS_STATE_T *process) + { + if (!process->inited) { ++#ifdef BUILD_WAYLAND ++ process->wl_global = NULL; ++#endif ++ + if (!khrn_pointer_map_init(&process->contexts, 64)) + return false; + +@@ -194,6 +202,13 @@ bool client_process_state_init(CLIENT_PROCESS_STATE_T *process) + } + #endif + ++#ifdef BUILD_WAYLAND ++ struct wl_display *wl_display = khrn_platform_get_wl_display(); ++ if (wl_display) ++ if (!init_process_wayland(process)) ++ return false; ++#endif ++ + process->inited = true; + } + +diff --git a/interface/khronos/common/khrn_client.h b/interface/khronos/common/khrn_client.h +index 804039b..615f7b4 100644 +--- a/interface/khronos/common/khrn_client.h ++++ b/interface/khronos/common/khrn_client.h +@@ -310,6 +310,16 @@ struct CLIENT_PROCESS_STATE { + #ifdef RPC_LIBRARY + KHRONOS_SERVER_CONNECTION_T khrn_connection; + #endif ++ ++#ifdef BUILD_WAYLAND ++ /* Client-side Wayland state */ ++ struct wl_registry *wl_registry; ++ struct wl_dispmanx *wl_dispmanx; ++ struct wl_event_queue *wl_queue; ++ ++ /* Compositor-side Wayland state */ ++ struct wl_global *wl_global; ++#endif + }; + + extern bool client_process_state_init(CLIENT_PROCESS_STATE_T *process); +diff --git a/interface/khronos/common/khrn_client_mangle.h b/interface/khronos/common/khrn_client_mangle.h +index b3c04f4..b7b21c5 100644 +--- a/interface/khronos/common/khrn_client_mangle.h ++++ b/interface/khronos/common/khrn_client_mangle.h +@@ -83,6 +83,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + #define eglReleaseGlobalImageBRCM mangled_eglReleaseGlobalImageBRCM + #define eglInitGlobalImageBRCM mangled_eglInitGlobalImageBRCM + #define eglTermGlobalImageBRCM mangled_eglTermGlobalImageBRCM ++#define eglBindWaylandDisplayWL mangled_eglBindWaylandDisplayWL ++#define eglUnbindWaylandDisplayWL mangled_eglUnbindWaylandDisplayWL ++#define eglQueryWaylandBufferWL mangled_eglQueryWaylandBufferWL + + /* OpenGL ES 1.1 and 2.0 functions */ + +diff --git a/interface/khronos/common/khrn_client_platform.h b/interface/khronos/common/khrn_client_platform.h +index 1c9da3a..715c67e 100644 +--- a/interface/khronos/common/khrn_client_platform.h ++++ b/interface/khronos/common/khrn_client_platform.h +@@ -48,6 +48,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + #include "interface/khronos/common/vcos/khrn_client_platform_filler_vcos.h" + #endif + ++#ifdef BUILD_WAYLAND ++#include ++#endif ++ + #ifdef __cplusplus + extern "C" { + #endif +@@ -328,4 +332,8 @@ typedef struct + + void *platform_wfc_bounce_thread(void *param); + ++#ifdef BUILD_WAYLAND ++struct wl_display *khrn_platform_get_wl_display(); ++#endif ++ + #endif // KHRN_CLIENT_PLATFORM_H +diff --git a/interface/khronos/common/khrn_client_unmangle.h b/interface/khronos/common/khrn_client_unmangle.h +index 4f3ce49..84f6ec0 100644 +--- a/interface/khronos/common/khrn_client_unmangle.h ++++ b/interface/khronos/common/khrn_client_unmangle.h +@@ -83,6 +83,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + #undef eglReleaseGlobalImageBRCM + #undef eglInitGlobalImageBRCM + #undef eglTermGlobalImageBRCM ++#undef eglBindWaylandDisplayWL ++#undef eglUnbindWaylandDisplayWL ++#undef eglQueryWaylandBufferWL + + /* OpenGL ES 1.1 and 2.0 functions */ + +diff --git a/interface/khronos/common/linux/khrn_client_platform_linux.c b/interface/khronos/common/linux/khrn_client_platform_linux.c +index 710d20f..50d60a6 100644 +--- a/interface/khronos/common/linux/khrn_client_platform_linux.c ++++ b/interface/khronos/common/linux/khrn_client_platform_linux.c +@@ -37,6 +37,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + #include "X11/Xlib.h" + #endif + ++#ifdef BUILD_WAYLAND ++#include ++#include "interface/khronos/wayland-egl/wayland-egl-priv.h" ++#endif ++ + extern VCOS_LOG_CAT_T khrn_client_log; + + extern void vc_vchi_khronos_init(); +@@ -464,13 +469,36 @@ EGLDisplay khrn_platform_set_display_id(EGLNativeDisplayType display_id) + return EGL_NO_DISPLAY; + } + #else ++ ++#ifdef BUILD_WAYLAND ++static struct wl_display *hacky_display = NULL; ++#endif ++ + EGLDisplay khrn_platform_set_display_id(EGLNativeDisplayType display_id) + { + if (display_id == EGL_DEFAULT_DISPLAY) + return (EGLDisplay)1; +- else +- return EGL_NO_DISPLAY; ++ else { ++#ifdef BUILD_WAYLAND ++ void *first_pointer = *(void **) display_id; ++ ++ /* wl_display is a wl_proxy, which is a wl_object. ++ * wl_object's first element points to the interfacetype. */ ++ if (first_pointer == &wl_display_interface) { ++ hacky_display = (struct wl_display*)display_id; ++ return (EGLDisplay)1; ++ } else ++#endif ++ return EGL_NO_DISPLAY; ++ } + } ++ ++#ifdef BUILD_WAYLAND ++struct wl_display *khrn_platform_get_wl_display() ++{ ++ return hacky_display; ++} ++#endif + #endif + + #ifdef WANT_X +@@ -805,22 +833,81 @@ static EGL_DISPMANX_WINDOW_T *check_default(EGLNativeWindowType win) + void platform_get_dimensions(EGLDisplay dpy, EGLNativeWindowType win, + uint32_t *width, uint32_t *height, uint32_t *swapchain_count) + { +- EGL_DISPMANX_WINDOW_T *dwin = check_default(win); +- vcos_assert(dwin); +- vcos_assert(dwin->width < 1<<16); // sanity check +- vcos_assert(dwin->height < 1<<16); // sanity check +- *width = dwin->width; +- *height = dwin->height; +- *swapchain_count = 0; ++#ifdef BUILD_WAYLAND ++ if(khrn_platform_get_wl_display()) { ++ struct wl_egl_window *wl_egl_window = (struct wl_egl_window*)win; ++ *width = wl_egl_window->width; ++ *height = wl_egl_window->height; ++ /* This seems to be used for sync'ing with the VC on buffer creation, but ++ we are managing them on the CPU side */ ++ *swapchain_count = 1; ++ } else { ++#endif ++ EGL_DISPMANX_WINDOW_T *dwin = check_default(win); ++ vcos_assert(dwin); ++ vcos_assert(dwin->width < 1<<16); // sanity check ++ vcos_assert(dwin->height < 1<<16); // sanity check ++ *width = dwin->width; ++ *height = dwin->height; ++ *swapchain_count = 0; ++#ifdef BUILD_WAYLAND ++ } ++#endif + } + ++#ifdef BUILD_WAYLAND ++static DISPMANX_ELEMENT_HANDLE_T create_dummy_element() ++{ ++ DISPMANX_DISPLAY_HANDLE_T display = vc_dispmanx_display_open(0); ++ DISPMANX_UPDATE_HANDLE_T update = vc_dispmanx_update_start(0); ++ DISPMANX_ELEMENT_HANDLE_T element; ++ VC_DISPMANX_ALPHA_T alpha = {DISPMANX_FLAGS_ALPHA_FIXED_ALL_PIXELS, 255, 0}; ++ VC_RECT_T src_rect; ++ VC_RECT_T dst_rect; ++ ++ src_rect.x = 0; ++ src_rect.y = 0; ++ src_rect.width = 1 << 16; ++ src_rect.height = 1 << 16; ++ ++ dst_rect.x = 0; ++ dst_rect.y = 0; ++ dst_rect.width = 1; ++ dst_rect.height = 1; ++ ++ element = vc_dispmanx_element_add(update, display, 0/*layer*/, &dst_rect, ++ 0/*src*/, &src_rect, ++ DISPMANX_PROTECTION_NONE, &alpha, ++ 0/*clamp*/, 0/*transform*/); ++ ++ vc_dispmanx_update_submit_sync(update); ++ ++ vc_dispmanx_display_close(display); ++ ++ return element; ++} ++#endif ++ + uint32_t platform_get_handle(EGLDisplay dpy, EGLNativeWindowType win) + { +- EGL_DISPMANX_WINDOW_T *dwin = check_default(win); +- vcos_assert(dwin); +- vcos_assert(dwin->width < 1<<16); // sanity check +- vcos_assert(dwin->height < 1<<16); // sanity check +- return dwin->element; ++#ifdef BUILD_WAYLAND ++ if(khrn_platform_get_wl_display()) { ++ struct wl_egl_window *wl_egl_window = (struct wl_egl_window*)win; ++ ++ if (wl_egl_window->dummy_element == PLATFORM_WIN_NONE) ++ wl_egl_window->dummy_element = create_dummy_element(); ++ ++ return wl_egl_window->dummy_element; ++ } else { ++#endif ++ EGL_DISPMANX_WINDOW_T *dwin = check_default(win); ++ vcos_assert(dwin); ++ vcos_assert(dwin->width < 1<<16); // sanity check ++ vcos_assert(dwin->height < 1<<16); // sanity check ++ return dwin->element; ++#ifdef BUILD_WAYLAND ++ } ++#endif + } + + #endif +diff --git a/interface/khronos/common/linux/khrn_wayland.c b/interface/khronos/common/linux/khrn_wayland.c +new file mode 100644 +index 0000000..0e1b9e7 +--- /dev/null ++++ b/interface/khronos/common/linux/khrn_wayland.c +@@ -0,0 +1,215 @@ ++/* ++Copyright (c) 2013, Raspberry Pi Foundation ++All rights reserved. ++ ++Redistribution and use in source and binary forms, with or without ++modification, are permitted provided that the following conditions are met: ++ * Redistributions of source code must retain the above copyright ++ notice, this list of conditions and the following disclaimer. ++ * Redistributions in binary form must reproduce the above copyright ++ notice, this list of conditions and the following disclaimer in the ++ documentation and/or other materials provided with the distribution. ++ * Neither the name of the copyright holder nor the ++ names of its contributors may be used to endorse or promote products ++ derived from this software without specific prior written permission. ++ ++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ++ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED ++WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE ++DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY ++DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ++(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ++ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS ++SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ++*/ ++ ++#define VCOS_LOG_CATEGORY (&khrn_client_log) ++ ++#include "interface/khronos/common/linux/khrn_wayland.h" ++#include "interface/khronos/wayland-dispmanx-client-protocol.h" ++#include "interface/khronos/wayland-egl/wayland-egl-priv.h" ++ ++extern VCOS_LOG_CAT_T khrn_client_log; ++ ++static void handle_dispmanx_format(void *data, struct wl_dispmanx *dispmanx, ++ uint32_t format) ++{ ++} ++ ++static void handle_dispmanx_allocated(void *data, struct wl_dispmanx *dispmanx, ++ struct wl_buffer *wl_buffer, ++ uint32_t resource_handle) ++{ ++ struct wl_dispmanx_client_buffer *buffer = wl_buffer_get_user_data(wl_buffer); ++ ++ buffer->pending_allocation = 0; ++ buffer->resource = resource_handle; ++} ++ ++static const struct wl_dispmanx_listener dispmanx_listener = { ++ handle_dispmanx_format, ++ handle_dispmanx_allocated, ++}; ++ ++static void ++sync_callback(void *data, struct wl_callback *callback, uint32_t serial) ++{ ++ int *done = data; ++ ++ *done = 1; ++ ++ wl_callback_destroy(callback); ++} ++ ++static const struct wl_callback_listener sync_listener = { ++ sync_callback ++}; ++ ++static int ++roundtrip(CLIENT_PROCESS_STATE_T *process) ++{ ++ struct wl_display *wl_display = khrn_platform_get_wl_display(); ++ struct wl_callback *callback; ++ int done = 0, ret = 0; ++ ++ callback = wl_display_sync(wl_display); ++ wl_callback_add_listener(callback, &sync_listener, &done); ++ wl_proxy_set_queue((struct wl_proxy *) callback, process->wl_queue); ++ while (ret != -1 && !done) ++ ret = wl_display_dispatch_queue(wl_display, process->wl_queue); ++ ++ if (!done) ++ wl_callback_destroy(callback); ++ ++ return ret; ++} ++ ++int do_wl_roundtrip() ++{ ++ CLIENT_PROCESS_STATE_T *process = CLIENT_GET_PROCESS_STATE(); ++ return roundtrip(process); ++} ++ ++static void ++registry_handle_global(void *data, struct wl_registry *registry, ++ uint32_t name, const char *interface, uint32_t version) ++{ ++ struct wl_display *wl_display = khrn_platform_get_wl_display(); ++ CLIENT_PROCESS_STATE_T *process = (CLIENT_PROCESS_STATE_T *)data; ++ ++ if (strcmp(interface, "wl_dispmanx") == 0) { ++ process->wl_dispmanx = wl_registry_bind(registry, name, ++ &wl_dispmanx_interface, 1); ++ ++ wl_proxy_set_queue((struct wl_proxy *) process->wl_dispmanx, ++ process->wl_queue); ++ wl_dispmanx_add_listener(process->wl_dispmanx, &dispmanx_listener, wl_display); ++ roundtrip(process); ++ } ++} ++ ++static void ++registry_handle_global_remove(void *data, struct wl_registry *registry, ++ uint32_t name) ++{ ++} ++ ++static const struct wl_registry_listener registry_listener = { ++ registry_handle_global, ++ registry_handle_global_remove ++}; ++ ++int ++init_process_wayland(CLIENT_PROCESS_STATE_T *process) ++{ ++ struct wl_display *wl_display = khrn_platform_get_wl_display(); ++ ++ process->wl_queue = wl_display_create_queue(wl_display); ++ if (!process->wl_queue) { ++ vcos_log_error("wl_display_create_queue failed\n"); ++ return false; ++ } ++ wl_display_dispatch_pending(wl_display); ++ ++ process->wl_registry = wl_display_get_registry(wl_display); ++ if (!process->wl_registry) { ++ vcos_log_error("wl_display_get_registry failed\n"); ++ return false; ++ } ++ ++ wl_proxy_set_queue((struct wl_proxy *) process->wl_registry, ++ process->wl_queue); ++ ++ wl_registry_add_listener(process->wl_registry, ®istry_listener, process); ++ ++ if (roundtrip(process) < 0 || process->wl_dispmanx == NULL) { ++ vcos_log_error("failed to get wl_dispmanx\n"); ++ return false; ++ } ++ ++ return true; ++} ++ ++#ifndef ALIGN_UP ++#define ALIGN_UP(x,y) ((x + (y)-1) & ~((y)-1)) ++#endif ++ ++static void handle_buffer_release(void *data, struct wl_buffer *buffer_wl) ++{ ++ struct wl_dispmanx_client_buffer *wl_dispmanx_client_buffer = data; ++ wl_dispmanx_client_buffer->in_use = 0; ++} ++ ++static const struct wl_buffer_listener buffer_listener = { ++ handle_buffer_release ++}; ++ ++struct wl_dispmanx_client_buffer * ++allocate_wl_buffer(struct wl_egl_window *window, KHRN_IMAGE_FORMAT_T color) ++{ ++ CLIENT_PROCESS_STATE_T *process = CLIENT_GET_PROCESS_STATE(); ++ struct wl_dispmanx_client_buffer *wl_dispmanx_client_buffer; ++ struct wl_buffer *wl_buffer; ++ uint32_t stride = ALIGN_UP(window->width * 4, 16); ++ uint32_t buffer_height = ALIGN_UP(window->height, 16); ++ enum wl_dispmanx_format color_format; ++ int ret = 0; ++ ++ switch (color) { ++ case ABGR_8888: ++ color_format = WL_DISPMANX_FORMAT_ABGR8888; ++ break; ++ case XBGR_8888: ++ color_format = WL_DISPMANX_FORMAT_XBGR8888; ++ break; ++ case RGB_565: ++ color_format = WL_DISPMANX_FORMAT_RGB565; ++ break; ++ default: ++ vcos_log_error("unknown KHRN_IMAGE_FORMAT_T 0x%x\n", color); ++ return NULL; ++ } ++ ++ wl_buffer = wl_dispmanx_create_buffer(process->wl_dispmanx, window->width, ++ window->height, stride, buffer_height, ++ color_format); ++ if (wl_buffer == NULL) ++ return NULL; ++ ++ wl_dispmanx_client_buffer = calloc(1, sizeof(struct wl_dispmanx_client_buffer)); ++ wl_dispmanx_client_buffer->wl_buffer = wl_buffer; ++ wl_dispmanx_client_buffer->in_use = 0; ++ wl_dispmanx_client_buffer->pending_allocation = 1; ++ wl_dispmanx_client_buffer->width = window->width; ++ wl_dispmanx_client_buffer->height = window->height; ++ ++ wl_proxy_set_queue((struct wl_proxy *) wl_buffer, process->wl_queue); ++ wl_buffer_add_listener(wl_buffer, &buffer_listener, wl_dispmanx_client_buffer); ++ ++ while (ret != -1 && wl_dispmanx_client_buffer->pending_allocation) ++ ret = do_wl_roundtrip(); ++ ++ return wl_dispmanx_client_buffer; ++} +diff --git a/interface/vmcs_host/vc_vchi_dispmanx.h b/interface/khronos/common/linux/khrn_wayland.h +similarity index 56% +copy from interface/vmcs_host/vc_vchi_dispmanx.h +copy to interface/khronos/common/linux/khrn_wayland.h +index b723b76..b9bf08c 100644 +--- a/interface/vmcs_host/vc_vchi_dispmanx.h ++++ b/interface/khronos/common/linux/khrn_wayland.h +@@ -1,5 +1,5 @@ + /* +-Copyright (c) 2012, Broadcom Europe Ltd ++Copyright (c) 2013, Raspberry Pi Foundation + All rights reserved. + + Redistribution and use in source and binary forms, with or without +@@ -25,45 +25,9 @@ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +-#ifndef VC_VCHI_DISPMANX_H +-#define VC_VCHI_DISPMANX_H ++#include "interface/khronos/common/khrn_client.h" + +-#include "interface/peer/vc_vchi_dispmanx_common.h" ++int init_process_wayland(CLIENT_PROCESS_STATE_T *process); ++int do_wl_roundtrip(); + +-#define VC_NUM_HOST_RESOURCES 64 +-#define DISPMANX_MSGFIFO_SIZE 1024 +-#define DISPMANX_CLIENT_NAME MAKE_FOURCC("DISP") +-#define DISPMANX_NOTIFY_NAME MAKE_FOURCC("UPDH") +- +-//Or with command to indicate we don't need a response +-#define DISPMANX_NO_REPLY_MASK (1<<31) +- +-typedef struct { +- char description[32]; +- uint32_t width; +- uint32_t height; +- uint32_t aspect_pixwidth; +- uint32_t aspect_pixheight; +- uint32_t fieldrate_num; +- uint32_t fieldrate_denom; +- uint32_t fields_per_frame; +- uint32_t transform; +-} GET_MODES_DATA_T; +- +-typedef struct { +- int32_t response; +- uint32_t width; +- uint32_t height; +- uint32_t transform; +- uint32_t input_format; +-} GET_INFO_DATA_T; +- +-//Attributes changes flag mask +-#define ELEMENT_CHANGE_LAYER (1<<0) +-#define ELEMENT_CHANGE_OPACITY (1<<1) +-#define ELEMENT_CHANGE_DEST_RECT (1<<2) +-#define ELEMENT_CHANGE_SRC_RECT (1<<3) +-#define ELEMENT_CHANGE_MASK_RESOURCE (1<<4) +-#define ELEMENT_CHANGE_TRANSFORM (1<<5) +- +-#endif ++struct wl_dispmanx_client_buffer *allocate_wl_buffer(struct wl_egl_window *window, KHRN_IMAGE_FORMAT_T color); +diff --git a/interface/khronos/egl/egl_client.c b/interface/khronos/egl/egl_client.c +index b8bb374..03fe67b 100644 +--- a/interface/khronos/egl/egl_client.c ++++ b/interface/khronos/egl/egl_client.c +@@ -153,6 +153,10 @@ by an attribute value" + #include + #include + ++#ifdef BUILD_WAYLAND ++#include "interface/khronos/wayland-egl/wayland-egl-priv.h" ++#include "interface/khronos/common/linux/khrn_wayland.h" ++#endif + + #include "interface/khronos/egl/egl_client_cr.c" + +@@ -162,17 +166,6 @@ static void egl_current_release(CLIENT_PROCESS_STATE_T *process, EGL_CURRENT_T * + void egl_gl_flush_callback(bool wait); + void egl_vg_flush_callback(bool wait); + +-#include "interface/vmcs_host/vc_dispmanx_types.h" +-/**HACKHACK - give us the ability to inject a DispmanX +- * resource handle into the CreateWindowSurface and +- * SwapBuffers calls */ +-static DISPMANX_RESOURCE_HANDLE_T next_resource_handle; +- +-EGLAPI EGLBoolean EGLAPIENTRY eglSetNextResourceHandle(DISPMANX_RESOURCE_HANDLE_T handle) +-{ +- next_resource_handle = handle; +-} +- + /* + TODO: do an RPC call to make sure the Khronos vll is loaded (and that it stays loaded until eglTerminate) + Also affects global image (and possibly others?) +@@ -450,6 +443,9 @@ EGLAPI const char EGLAPIENTRY * eglQueryString(EGLDisplay dpy, EGLint name) + #ifdef EGL_KHR_fence_sync + "EGL_KHR_fence_sync " + #endif ++#endif ++#if EGL_WL_bind_wayland_display ++ "EGL_WL_bind_wayland_display " + #endif + ; + break; +@@ -655,8 +651,7 @@ EGLAPI EGLSurface EGLAPIENTRY eglCreateWindowSurface(EGLDisplay dpy, EGLConfig c + false, + EGL_NO_TEXTURE, + EGL_NO_TEXTURE, +- 0, 0, +- next_resource_handle); ++ 0, 0); + + if (surface) { + if (khrn_pointer_map_insert(&process->surfaces, process->next_surface, surface)) { +@@ -901,7 +896,7 @@ EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig + mipmap_texture, + texture_format, + texture_target, +- 0, 0, 0); ++ 0, 0); + + if (surface) { + if (khrn_pointer_map_insert(&process->surfaces, process->next_surface, surface)) { +@@ -1043,7 +1038,7 @@ EGLAPI EGLSurface EGLAPIENTRY eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig c + false, + EGL_NO_TEXTURE, + EGL_NO_TEXTURE, +- pixmap, ((server_handle[0] == 0) && (server_handle[1] == (uint32_t)(-1))) ? NULL : server_handle, 0); ++ pixmap, ((server_handle[0] == 0) && (server_handle[1] == (uint32_t)(-1))) ? NULL : server_handle); + + if (surface) { + if (khrn_pointer_map_insert(&process->surfaces, process->next_surface, surface)) { +@@ -2245,6 +2240,9 @@ EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffers(EGLDisplay dpy, EGLSurface surf) + CLIENT_THREAD_STATE_T *thread; + CLIENT_PROCESS_STATE_T *process; + EGLBoolean result; ++#ifdef BUILD_WAYLAND ++ struct wl_display *wl_display = khrn_platform_get_wl_display(); ++#endif + + vcos_log_trace("eglSwapBuffers start. dpy=%d. surf=%d.", (int)dpy, (int)surf); + +@@ -2315,18 +2313,58 @@ EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffers(EGLDisplay dpy, EGLSurface surf) + + vcos_log_trace("eglSwapBuffers server call"); + +- if (next_resource_handle) +- RPC_CALL7(eglIntSwapBuffers_impl, +- thread, +- EGLINTSWAPBUFFERS_ID_V2, +- RPC_UINT(surface->serverbuffer), +- RPC_UINT(surface->width), +- RPC_UINT(surface->height), +- RPC_UINT(surface->internal_handle), +- RPC_UINT(surface->swap_behavior == EGL_BUFFER_PRESERVED ? 1 : 0), +- RPC_UINT(khrn_platform_get_window_position(surface->win)), +- RPC_INT(next_resource_handle)); +- else ++#ifdef BUILD_WAYLAND ++ if (wl_display) { ++ struct wl_egl_window *wl_egl_window = surface->wl_egl_window; ++ struct wl_dispmanx_client_buffer *buffer_temp; ++ uint32_t configid; ++ KHRN_IMAGE_FORMAT_T color; ++ int ret = 0; ++ ++ buffer_temp = surface->front_wl_buffer; ++ surface->front_wl_buffer = surface->back_wl_buffer; ++ surface->back_wl_buffer = buffer_temp; ++ ++ configid = egl_config_to_id(surface->config); ++ color = egl_config_get_color_format(configid); ++ ++ if (surface->back_wl_buffer == NULL) ++ surface->back_wl_buffer = allocate_wl_buffer(wl_egl_window, color); ++ else if (surface->back_wl_buffer->width != width || ++ surface->back_wl_buffer->height != height) { ++ ++ struct wl_dispmanx_client_buffer *buffer; ++ ++ wl_buffer_destroy(surface->back_wl_buffer->wl_buffer); ++ free(surface->back_wl_buffer); ++ ++ buffer = allocate_wl_buffer(wl_egl_window, color); ++ surface->back_wl_buffer = buffer; ++ } ++ ++ RPC_CALL7(eglIntSwapBuffers_impl, ++ thread, ++ EGLINTSWAPBUFFERS_ID_V2, ++ RPC_UINT(surface->serverbuffer), ++ RPC_UINT(surface->width), ++ RPC_UINT(surface->height), ++ RPC_UINT(surface->internal_handle), ++ RPC_UINT(surface->swap_behavior == EGL_BUFFER_PRESERVED ? 1 : 0), ++ RPC_UINT(khrn_platform_get_window_position(surface->win)), ++ RPC_INT(surface->back_wl_buffer->resource)); ++ ++ surface->front_wl_buffer->in_use = 1; ++ wl_surface_attach(wl_egl_window->wl_surface, ++ surface->front_wl_buffer->wl_buffer, ++ 0, 0); ++ wl_surface_damage(wl_egl_window->wl_surface, 0, 0, ++ surface->width, surface->height); ++ wl_surface_commit(wl_egl_window->wl_surface); ++ ++ while(ret != -1 && surface->back_wl_buffer->in_use) ++ ret = wl_display_dispatch_queue(wl_display, process->wl_queue); ++ } else ++#endif + RPC_CALL6(eglIntSwapBuffers_impl, + thread, + EGLINTSWAPBUFFERS_ID, +diff --git a/interface/khronos/egl/egl_client_get_proc.c b/interface/khronos/egl/egl_client_get_proc.c +index 4cfa9ff..6a715af 100644 +--- a/interface/khronos/egl/egl_client_get_proc.c ++++ b/interface/khronos/egl/egl_client_get_proc.c +@@ -254,6 +254,17 @@ EGLAPI void EGLAPIENTRY (* eglGetProcAddress(const char *procname))(void) + return (void(*)(void))eglQueryGlobalImageBRCM; + #endif + ++#ifdef BUILD_WAYLAND ++#if EGL_WL_bind_wayland_display ++ if (!strcmp(procname, "eglBindWaylandDisplayWL")) ++ return (void(*)(void))eglBindWaylandDisplayWL; ++ if (!strcmp(procname, "eglUnbindWaylandDisplayWL")) ++ return (void(*)(void))eglUnbindWaylandDisplayWL; ++ if (!strcmp(procname, "eglQueryWaylandBufferWL")) ++ return (void(*)(void))eglQueryWaylandBufferWL; ++#endif ++#endif ++ + return (void(*)(void)) NULL; + } + +diff --git a/interface/khronos/egl/egl_client_surface.c b/interface/khronos/egl/egl_client_surface.c +index 128325e..42350bf 100644 +--- a/interface/khronos/egl/egl_client_surface.c ++++ b/interface/khronos/egl/egl_client_surface.c +@@ -46,6 +46,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + #include "interface/khronos/egl/egl_int_impl.h" + #endif + ++#ifdef BUILD_WAYLAND ++#include "interface/khronos/wayland-egl/wayland-egl-priv.h" ++#include "interface/khronos/common/linux/khrn_wayland.h" ++#endif ++ + #include + + +@@ -314,8 +319,7 @@ EGL_SURFACE_T *egl_surface_create( + EGLenum texture_format, + EGLenum texture_target, + EGLNativePixmapType pixmap, +- const uint32_t *pixmap_server_handle, +- DISPMANX_RESOURCE_HANDLE_T next_resource_handle) ++ const uint32_t *pixmap_server_handle) + { + KHRN_IMAGE_FORMAT_T color; + KHRN_IMAGE_FORMAT_T depth; +@@ -326,6 +330,10 @@ EGL_SURFACE_T *egl_surface_create( + EGLint config_depth_bits; + EGLint config_stencil_bits; + CLIENT_THREAD_STATE_T *thread = CLIENT_GET_THREAD_STATE(); ++#ifdef BUILD_WAYLAND ++ struct wl_display *wl_display = khrn_platform_get_wl_display(); ++ DISPMANX_RESOURCE_HANDLE_T resource; ++#endif + + EGL_SURFACE_T *surface = egl_surface_pool_alloc(); + +@@ -390,6 +398,18 @@ EGL_SURFACE_T *egl_surface_create( + + vcos_assert(color != IMAGE_FORMAT_INVALID); + ++#ifdef BUILD_WAYLAND ++ if (type == WINDOW && wl_display) { ++ surface->wl_egl_window = (struct wl_egl_window*)win; ++ surface->back_wl_buffer = allocate_wl_buffer( ++ surface->wl_egl_window, color); ++ resource = surface->back_wl_buffer->resource; ++ } else { ++ surface->wl_egl_window = NULL; ++ resource = DISPMANX_NO_HANDLE; ++ } ++#endif ++ + #ifdef KHRONOS_EGL_PLATFORM_OPENWFC + // Create stream for this window + if(type != PBUFFER) +@@ -474,7 +494,8 @@ EGL_SURFACE_T *egl_surface_create( + #endif + uint32_t results[3]; + +- if (next_resource_handle) ++#ifdef BUILD_WAYLAND ++ if (resource != DISPMANX_NO_HANDLE) + RPC_CALL16_OUT_CTRL(eglIntCreateSurface_impl, + thread, + EGLINTCREATESURFACE_ID_V2, +@@ -492,9 +513,10 @@ EGL_SURFACE_T *egl_surface_create( + RPC_UINT(config_stencil_bits), + RPC_UINT(sem_name), + RPC_UINT(type), +- RPC_INT(next_resource_handle), ++ RPC_INT(resource), + results); + else ++#endif + RPC_CALL15_OUT_CTRL(eglIntCreateSurface_impl, + thread, + EGLINTCREATESURFACE_ID, +@@ -663,6 +685,18 @@ void egl_surface_free(EGL_SURFACE_T *surface) + if( surface->type == WINDOW ) { + vcos_log_trace("egl_surface_free: calling platform_destroy_winhandle..."); + platform_destroy_winhandle( surface->win, surface->internal_handle ); ++ ++#ifdef BUILD_WAYLAND ++ if (surface->back_wl_buffer) { ++ wl_buffer_destroy(surface->back_wl_buffer->wl_buffer); ++ free(surface->back_wl_buffer); ++ } ++ ++ if (surface->front_wl_buffer) { ++ wl_buffer_destroy(surface->front_wl_buffer->wl_buffer); ++ free(surface->front_wl_buffer); ++ } ++#endif + } + /* return value ignored -- read performed to ensure blocking. we want this to + * block so clients can safely destroy the surface's window as soon as the +diff --git a/interface/khronos/egl/egl_client_surface.h b/interface/khronos/egl/egl_client_surface.h +index b5bf70a..e328b77 100644 +--- a/interface/khronos/egl/egl_client_surface.h ++++ b/interface/khronos/egl/egl_client_surface.h +@@ -288,6 +288,41 @@ typedef struct { + type == PIXMAP + */ + bool server_owned; ++ ++#ifdef BUILD_WAYLAND ++ /* ++ wl_egl_window ++ ++ Validity: ++ type == WINDOW ++ ++ Invariant: ++ wayland EGL window ++ */ ++ struct wl_egl_window *wl_egl_window; ++ ++ /* ++ front_wl_buffer ++ ++ Validity: ++ type == WINDOW ++ ++ Invariant: ++ client-side information about the wl_buffer in the front ++ */ ++ struct wl_dispmanx_client_buffer *front_wl_buffer; ++ ++ /* ++ back_wl_buffer ++ ++ Validity: ++ type == WINDOW ++ ++ Invariant: ++ client-side information about the wl_buffer in the back ++ */ ++ struct wl_dispmanx_client_buffer *back_wl_buffer; ++#endif + } EGL_SURFACE_T; + + extern bool egl_surface_check_attribs( +@@ -322,8 +357,7 @@ extern EGL_SURFACE_T *egl_surface_create( + EGLenum texture_format, + EGLenum texture_target, + EGLNativePixmapType pixmap, +- const uint32_t *pixmap_server_handle, +- DISPMANX_RESOURCE_HANDLE_T next_resource_handle); ++ const uint32_t *pixmap_server_handle); + extern EGL_SURFACE_T *egl_surface_from_vg_image( + VGImage vg_handle, + EGLSurface name, +diff --git a/interface/khronos/egl/egl_int_impl.h b/interface/khronos/egl/egl_int_impl.h +index 51b3580..6863a3b 100644 +--- a/interface/khronos/egl/egl_int_impl.h ++++ b/interface/khronos/egl/egl_int_impl.h +@@ -57,7 +57,7 @@ FN(int, eglIntCreateSurface_impl, ( + uint32_t sem, + uint32_t type, + uint32_t *results, +- DISPMANX_RESOURCE_HANDLE_T next_resource_handle)) ++ DISPMANX_RESOURCE_HANDLE_T resource_handle)) + + FN(int, eglIntCreatePbufferFromVGImage_impl, ( + VGImage vg_handle, +diff --git a/interface/khronos/ext/egl_wayland.c b/interface/khronos/ext/egl_wayland.c +new file mode 100644 +index 0000000..5730743 +--- /dev/null ++++ b/interface/khronos/ext/egl_wayland.c +@@ -0,0 +1,246 @@ ++/* ++Copyright (c) 2013, Raspberry Pi Foundation ++All rights reserved. ++ ++Redistribution and use in source and binary forms, with or without ++modification, are permitted provided that the following conditions are met: ++ * Redistributions of source code must retain the above copyright ++ notice, this list of conditions and the following disclaimer. ++ * Redistributions in binary form must reproduce the above copyright ++ notice, this list of conditions and the following disclaimer in the ++ documentation and/or other materials provided with the distribution. ++ * Neither the name of the copyright holder nor the ++ names of its contributors may be used to endorse or promote products ++ derived from this software without specific prior written permission. ++ ++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ++ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED ++WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE ++DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY ++DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ++(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ++ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS ++SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ++*/ ++ ++#include "interface/khronos/common/khrn_client_mangle.h" ++#include "interface/khronos/common/khrn_client_rpc.h" ++ ++#include "interface/khronos/ext/egl_khr_sync_client.h" ++#include "interface/khronos/include/EGL/egl.h" ++#include "interface/khronos/include/EGL/eglext.h" ++ ++#include "interface/vmcs_host/vc_vchi_dispmanx.h" ++ ++#include ++#include "interface/khronos/wayland-dispmanx-server-protocol.h" ++ ++static void ++destroy_buffer(struct wl_resource *resource) ++{ ++ struct wl_dispmanx_server_buffer *buffer = wl_resource_get_user_data(resource); ++ ++ if(!buffer->in_use) ++ vc_dispmanx_resource_delete(buffer->handle); ++ ++ free(buffer); ++} ++ ++static void ++buffer_destroy(struct wl_client *client, struct wl_resource *resource) ++{ ++ wl_resource_destroy(resource); ++} ++ ++static const struct wl_buffer_interface dispmanx_buffer_interface = { ++ buffer_destroy ++}; ++ ++static VC_IMAGE_TYPE_T ++get_vc_format(enum wl_dispmanx_format format) ++{ ++ /* XXX: The app is likely to have been premultiplying in its shaders, ++ * but the VC scanout hardware on the RPi cannot mix premultiplied alpha ++ * channel with the element's alpha. ++ */ ++ switch (format) { ++ case WL_DISPMANX_FORMAT_ABGR8888: ++ return VC_IMAGE_RGBA32; ++ case WL_DISPMANX_FORMAT_XBGR8888: ++ return VC_IMAGE_BGRX8888; ++ case WL_DISPMANX_FORMAT_RGB565: ++ return VC_IMAGE_RGB565; ++ default: ++ /* invalid format */ ++ return VC_IMAGE_MIN; ++ } ++} ++ ++static void ++dispmanx_create_buffer(struct wl_client *client, struct wl_resource *resource, ++ uint32_t id, int32_t width, int32_t height, ++ uint32_t stride, uint32_t buffer_height, uint32_t format) ++{ ++ struct wl_dispmanx_server_buffer *buffer; ++ VC_IMAGE_TYPE_T vc_format = get_vc_format(format); ++ uint32_t dummy; ++ ++ if(vc_format == VC_IMAGE_MIN) { ++ wl_resource_post_error(resource, ++ WL_DISPMANX_ERROR_INVALID_FORMAT, ++ "invalid format"); ++ return; ++ } ++ ++ buffer = calloc(1, sizeof *buffer); ++ if (buffer == NULL) { ++ wl_resource_post_no_memory(resource); ++ return; ++ } ++ ++ buffer->handle = vc_dispmanx_resource_create(vc_format, ++ width | (stride << 16), ++ height | (buffer_height << 16), ++ &dummy); ++ if(buffer->handle == DISPMANX_NO_HANDLE) { ++ wl_resource_post_error(resource, ++ WL_DISPMANX_ERROR_ALLOC_FAILED, ++ "allocation failed"); ++ free(buffer); ++ return; ++ } ++ ++ buffer->width = width; ++ buffer->height = height; ++ buffer->format = format; ++ ++ buffer->resource = wl_resource_create(resource->client, &wl_buffer_interface, ++ 1, id); ++ if (!buffer->resource) { ++ wl_resource_post_no_memory(resource); ++ vc_dispmanx_resource_delete(buffer->handle); ++ free(buffer); ++ return; ++ } ++ ++ wl_resource_set_implementation(buffer->resource, ++ (void (**)(void)) &dispmanx_buffer_interface, ++ buffer, destroy_buffer); ++ ++ wl_dispmanx_send_buffer_allocated(resource, buffer->resource, ++ buffer->handle); ++} ++ ++static const struct wl_dispmanx_interface dispmanx_interface = { ++ dispmanx_create_buffer, ++}; ++ ++static void ++bind_dispmanx(struct wl_client *client, void *data, uint32_t version, uint32_t id) ++{ ++ struct wl_resource *resource; ++ ++ resource = wl_resource_create(client, &wl_dispmanx_interface, 1, id); ++ wl_resource_set_implementation(resource, &dispmanx_interface, NULL, NULL); ++ ++ wl_resource_post_event(resource, WL_DISPMANX_FORMAT, ++ WL_DISPMANX_FORMAT_ARGB8888); ++ ++ wl_resource_post_event(resource, WL_DISPMANX_FORMAT, ++ WL_DISPMANX_FORMAT_XRGB8888); ++ ++ wl_resource_post_event(resource, WL_DISPMANX_FORMAT, ++ WL_DISPMANX_FORMAT_ABGR8888); ++ ++ wl_resource_post_event(resource, WL_DISPMANX_FORMAT, ++ WL_DISPMANX_FORMAT_XBGR8888); ++ ++ wl_resource_post_event(resource, WL_DISPMANX_FORMAT, ++ WL_DISPMANX_FORMAT_RGB565); ++} ++ ++EGLBoolean EGLAPIENTRY ++eglBindWaylandDisplayWL(EGLDisplay dpy, struct wl_display *display) ++{ ++ CLIENT_THREAD_STATE_T *thread; ++ CLIENT_PROCESS_STATE_T *process; ++ ++ if (!CLIENT_LOCK_AND_GET_STATES(dpy, &thread, &process)) ++ return EGL_FALSE; ++ ++ if (process->wl_global != NULL) ++ goto error; ++ ++ process->wl_global = wl_global_create(display, &wl_dispmanx_interface, 1, ++ NULL, bind_dispmanx); ++ if (process->wl_global == NULL) ++ goto error; ++ ++ return EGL_TRUE; ++ ++error: ++ CLIENT_UNLOCK(); ++ return EGL_FALSE; ++} ++ ++EGLBoolean EGLAPIENTRY ++eglUnbindWaylandDisplayWL(EGLDisplay dpy, struct wl_display *display) ++{ ++ CLIENT_THREAD_STATE_T *thread; ++ CLIENT_PROCESS_STATE_T *process; ++ ++ if (!CLIENT_LOCK_AND_GET_STATES(dpy, &thread, &process)) ++ return EGL_FALSE; ++ ++ wl_global_destroy(process->wl_global); ++ process->wl_global = NULL; ++ ++ CLIENT_UNLOCK(); ++ ++ return EGL_TRUE; ++} ++ ++static int ++get_egl_format(enum wl_dispmanx_format format) ++{ ++ switch (format) { ++ case WL_DISPMANX_FORMAT_ABGR8888: ++ return EGL_TEXTURE_RGBA; ++ case WL_DISPMANX_FORMAT_XBGR8888: ++ return EGL_TEXTURE_RGB; ++ case WL_DISPMANX_FORMAT_RGB565: ++ return EGL_TEXTURE_RGB; ++ default: ++ /* invalid format */ ++ return EGL_NO_TEXTURE; ++ } ++} ++ ++EGLBoolean EGLAPIENTRY ++eglQueryWaylandBufferWL(EGLDisplay dpy, struct wl_resource *_buffer, ++ EGLint attribute, EGLint *value) ++{ ++ struct wl_dispmanx_server_buffer *buffer = wl_resource_get_user_data(_buffer); ++ ++ if (wl_resource_instance_of(_buffer, &wl_dispmanx_interface, ++ &dispmanx_buffer_interface)) ++ return EGL_FALSE; ++ ++ switch (attribute) { ++ case EGL_TEXTURE_FORMAT: ++ *value = get_egl_format(buffer->format); ++ if (*value == EGL_NO_TEXTURE) ++ return EGL_FALSE; ++ return EGL_TRUE; ++ case EGL_WIDTH: ++ *value = buffer->width; ++ return EGL_TRUE; ++ case EGL_HEIGHT: ++ *value = buffer->height; ++ return EGL_TRUE; ++ } ++ ++ return EGL_FALSE; ++} +diff --git a/interface/khronos/include/EGL/eglext.h b/interface/khronos/include/EGL/eglext.h +index 89a3369..d7e5ba7 100755 +--- a/interface/khronos/include/EGL/eglext.h ++++ b/interface/khronos/include/EGL/eglext.h +@@ -191,6 +191,29 @@ typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETSYNCATTRIBKHRPROC) (EGLDisplay dpy, EG + #endif + + ++#ifndef EGL_WL_bind_wayland_display ++#define EGL_WL_bind_wayland_display 1 ++ ++#define EGL_WAYLAND_BUFFER_WL 0x31D5 /* eglCreateImageKHR target */ ++#define EGL_WAYLAND_PLANE_WL 0x31D6 /* eglCreateImageKHR target */ ++#define EGL_TEXTURE_Y_U_V_WL 0x31D7 ++#define EGL_TEXTURE_Y_UV_WL 0x31D8 ++#define EGL_TEXTURE_Y_XUXV_WL 0x31D9 ++ ++struct wl_display; ++struct wl_resource; ++#ifdef EGL_EGLEXT_PROTOTYPES ++EGLAPI EGLBoolean EGLAPIENTRY eglBindWaylandDisplayWL(EGLDisplay dpy, struct wl_display *display); ++EGLAPI EGLBoolean EGLAPIENTRY eglUnbindWaylandDisplayWL(EGLDisplay dpy, struct wl_display *display); ++EGLAPI EGLBoolean EGLAPIENTRY eglQueryWaylandBufferWL(EGLDisplay dpy, struct wl_resource *buffer, EGLint attribute, EGLint *value); ++#endif ++typedef EGLBoolean (EGLAPIENTRYP PFNEGLBINDWAYLANDDISPLAYWL) (EGLDisplay dpy, struct wl_display *display); ++typedef EGLBoolean (EGLAPIENTRYP PFNEGLUNBINDWAYLANDDISPLAYWL) (EGLDisplay dpy, struct wl_display *display); ++typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYWAYLANDBUFFERWL) (EGLDisplay dpy, struct wl_resource *buffer, EGLint attribute, EGLint *value); ++ ++#endif ++ ++ + #ifdef __cplusplus + } + #endif +diff --git a/interface/khronos/wayland-egl/wayland-egl-priv.h b/interface/khronos/wayland-egl/wayland-egl-priv.h +new file mode 100644 +index 0000000..8e38d36 +--- /dev/null ++++ b/interface/khronos/wayland-egl/wayland-egl-priv.h +@@ -0,0 +1,53 @@ ++/* Copied from Mesa */ ++ ++#ifndef _WAYLAND_EGL_PRIV_H ++#define _WAYLAND_EGL_PRIV_H ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* GCC visibility */ ++#if defined(__GNUC__) && __GNUC__ >= 4 ++#define WL_EGL_EXPORT __attribute__ ((visibility("default"))) ++#else ++#define WL_EGL_EXPORT ++#endif ++ ++#include "interface/vmcs_host/vc_dispmanx.h" ++#include "interface/khronos/egl/egl_client_surface.h" ++ ++#include ++ ++struct wl_dispmanx_client_buffer { ++ struct wl_buffer *wl_buffer; ++ DISPMANX_RESOURCE_HANDLE_T resource; ++ ++ int pending_allocation; ++ int in_use; ++ int width; ++ int height; ++}; ++ ++struct wl_egl_window { ++ struct wl_surface *wl_surface; ++ ++ int width; ++ int height; ++ int dx; ++ int dy; ++ ++ int attached_width; ++ int attached_height; ++ ++ /* XXX: The VC side seems to expect a valid element handle to be ++ passed to eglIntCreateSurface_impl and/or eglIntSwapBuffers_impl, ++ even for host-managed surfaces. */ ++ DISPMANX_ELEMENT_HANDLE_T dummy_element; ++}; ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff --git a/interface/khronos/wayland-egl/wayland-egl.c b/interface/khronos/wayland-egl/wayland-egl.c +new file mode 100644 +index 0000000..b8f050b +--- /dev/null ++++ b/interface/khronos/wayland-egl/wayland-egl.c +@@ -0,0 +1,59 @@ ++/* Copied from Mesa */ ++ ++#include ++ ++#include ++#include ++#include "wayland-egl-priv.h" ++ ++WL_EGL_EXPORT void ++wl_egl_window_resize(struct wl_egl_window *egl_window, ++ int width, int height, ++ int dx, int dy) ++{ ++ if (egl_window->width == width && ++ egl_window->height == height && ++ egl_window->dx == dx && ++ egl_window->dy == dy) ++ return; ++ ++ egl_window->width = width; ++ egl_window->height = height; ++ egl_window->dx = dx; ++ egl_window->dy = dy; ++} ++ ++WL_EGL_EXPORT struct wl_egl_window * ++wl_egl_window_create(struct wl_surface *surface, ++ int width, int height) ++{ ++ struct wl_egl_window *egl_window; ++ ++ egl_window = calloc(1, sizeof *egl_window); ++ if (!egl_window) ++ return NULL; ++ ++ egl_window->wl_surface = surface; ++ wl_egl_window_resize(egl_window, width, height, 0, 0); ++ egl_window->attached_width = 0; ++ egl_window->attached_height = 0; ++ egl_window->dummy_element = PLATFORM_WIN_NONE; ++ ++ return egl_window; ++} ++ ++WL_EGL_EXPORT void ++wl_egl_window_destroy(struct wl_egl_window *egl_window) ++{ ++ free(egl_window); ++} ++ ++WL_EGL_EXPORT void ++wl_egl_window_get_attached_size(struct wl_egl_window *egl_window, ++ int *width, int *height) ++{ ++ if (width) ++ *width = egl_window->attached_width; ++ if (height) ++ *height = egl_window->attached_height; ++} +diff --git a/interface/khronos/wayland-egl/wayland-egl.pc.in b/interface/khronos/wayland-egl/wayland-egl.pc.in +new file mode 100644 +index 0000000..8bafc15 +--- /dev/null ++++ b/interface/khronos/wayland-egl/wayland-egl.pc.in +@@ -0,0 +1,10 @@ ++prefix=@CMAKE_INSTALL_PREFIX@ ++exec_prefix=${prefix} ++libdir=${exec_prefix}/lib ++includedir=${prefix}/include ++ ++Name: wayland-egl ++Description: VideoCore wayland-egl library ++Version: @PROJECT_APIVER@ ++Libs: -L${libdir} -lwayland-egl ++Cflags: -I${includedir} +diff --git a/interface/vmcs_host/CMakeLists.txt b/interface/vmcs_host/CMakeLists.txt +index fde18da..6718215 100755 +--- a/interface/vmcs_host/CMakeLists.txt ++++ b/interface/vmcs_host/CMakeLists.txt +@@ -9,13 +9,24 @@ add_definitions(-fno-strict-aliasing) + + include_directories(${VMCS_TARGET}/vcfiled) + +-add_library(vchostif +- ${VMCS_TARGET}/vcfilesys.c ${VMCS_TARGET}/vcmisc.c +- vc_vchi_gencmd.c vc_vchi_filesys.c vc_vchi_gpuserv.c +- vc_vchi_tvservice.c vc_vchi_cecservice.c +- vc_vchi_dispmanx.c vc_service_common.c) ++set(VCHOSTIF_SOURCE ++ ${VMCS_TARGET}/vcfilesys.c ${VMCS_TARGET}/vcmisc.c ++ vc_vchi_gencmd.c vc_vchi_filesys.c vc_vchi_gpuserv.c ++ vc_vchi_tvservice.c vc_vchi_cecservice.c ++ vc_vchi_dispmanx.c vc_service_common.c) + # ${VMCS_TARGET}/vmcs_main.c + # vc_vchi_haud.c ++ ++if (BUILD_WAYLAND) ++wayland_add_protocol_server( ++ VCHOSTIF_SOURCE ++ ../../interface/wayland/dispmanx.xml ++ dispmanx ++) ++endif () ++ ++add_library(vchostif ${VCHOSTIF_SOURCE}) ++ + #add_library(bufman vc_vchi_bufman.c ) + + # OpenMAX/IL component service +diff --git a/interface/vmcs_host/vc_dispmanx.h b/interface/vmcs_host/vc_dispmanx.h +index 37fdae1..fe3619a 100755 +--- a/interface/vmcs_host/vc_dispmanx.h ++++ b/interface/vmcs_host/vc_dispmanx.h +@@ -39,6 +39,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + #ifdef __cplusplus + extern "C" { + #endif ++ ++#ifdef BUILD_WAYLAND ++struct wl_resource; ++#endif ++ + // Same function as above, to aid migration of code. + VCHPRE_ int VCHPOST_ vc_dispman_init( void ); + // Stop the service from being used +@@ -135,6 +140,11 @@ VCHPRE_ int VCHPOST_ vc_dispmanx_resource_set_palette( DISPMANX_RESOURCE_HANDLE_ + // Start triggering callbacks synced to vsync + VCHPRE_ int VCHPOST_ vc_dispmanx_vsync_callback( DISPMANX_DISPLAY_HANDLE_T display, DISPMANX_CALLBACK_FUNC_T cb_func, void *cb_arg ); + ++#ifdef BUILD_WAYLAND ++VCHPRE_ DISPMANX_RESOURCE_HANDLE_T VCHPOST_ vc_dispmanx_get_handle_from_wl_buffer( struct wl_resource *_buffer ); ++ ++VCHPRE_ void VCHPOST_ vc_dispmanx_set_wl_buffer_in_use( struct wl_resource *_buffer, int in_use ); ++#endif + #ifdef __cplusplus + } + #endif +diff --git a/interface/vmcs_host/vc_vchi_dispmanx.c b/interface/vmcs_host/vc_vchi_dispmanx.c +index 7a6cdcd..eab146e 100755 +--- a/interface/vmcs_host/vc_vchi_dispmanx.c ++++ b/interface/vmcs_host/vc_vchi_dispmanx.c +@@ -1319,3 +1319,45 @@ static void *dispmanx_notify_func( void *arg ) { + } + return 0; + } ++ ++ ++#ifdef BUILD_WAYLAND ++/*********************************************************** ++ * Name: vc_dispmanx_get_handle_from_wl_buffer ++ * ++ * Arguments: ++ * struct wl_resource *_buffer ++ * ++ * Description: Return the handle of the resource associated to this Wayland buffer ++ * ++ * Returns: A resource handle ++ * ++ ***********************************************************/ ++VCHPRE_ DISPMANX_RESOURCE_HANDLE_T VCHPOST_ vc_dispmanx_get_handle_from_wl_buffer( struct wl_resource *_buffer ) ++{ ++ struct wl_dispmanx_server_buffer *buffer = (struct wl_dispmanx_server_buffer*)_buffer->data; ++ if (!buffer) ++ return DISPMANX_NO_HANDLE; ++ ++ return buffer->handle; ++} ++ ++/*********************************************************** ++ * Name: vc_dispmanx_set_wl_buffer_in_use ++ * ++ * Arguments: ++ * struct wl_resource *_buffer ++ * int in_use ++ * ++ * Description: Mark this Wayland buffer as being in use by the compositor ++ * ++ ***********************************************************/ ++VCHPRE_ void VCHPOST_ vc_dispmanx_set_wl_buffer_in_use( struct wl_resource *_buffer, int in_use ) ++{ ++ struct wl_dispmanx_server_buffer *buffer = (struct wl_dispmanx_server_buffer*)_buffer->data; ++ if (!buffer) ++ return; ++ ++ buffer->in_use = in_use; ++} ++#endif +diff --git a/interface/vmcs_host/vc_vchi_dispmanx.h b/interface/vmcs_host/vc_vchi_dispmanx.h +index b723b76..f0bae30 100644 +--- a/interface/vmcs_host/vc_vchi_dispmanx.h ++++ b/interface/vmcs_host/vc_vchi_dispmanx.h +@@ -66,4 +66,19 @@ typedef struct { + #define ELEMENT_CHANGE_MASK_RESOURCE (1<<4) + #define ELEMENT_CHANGE_TRANSFORM (1<<5) + ++#ifdef BUILD_WAYLAND ++/* XXX: This should be in a private header that can be included from EGL and vc_* */ ++#include ++#include "interface/vmcs_host/wayland-dispmanx-server-protocol.h" ++struct wl_dispmanx_server_buffer { ++ struct wl_resource *resource; ++ struct wl_dispmanx *dispmanx; ++ enum wl_dispmanx_format format; ++ DISPMANX_RESOURCE_HANDLE_T handle; ++ int32_t width; ++ int32_t height; ++ int in_use; ++}; ++#endif ++ + #endif +diff --git a/interface/wayland/dispmanx.xml b/interface/wayland/dispmanx.xml +new file mode 100644 +index 0000000..c18626d +--- /dev/null ++++ b/interface/wayland/dispmanx.xml +@@ -0,0 +1,123 @@ ++ ++ ++ ++ ++ Copyright © 2008-2011 Kristian Høgsberg ++ Copyright © 2010-2011 Intel Corporation ++ Copyright © 2013 Raspberry Pi Foundation ++ ++ Permission to use, copy, modify, distribute, and sell this ++ software and its documentation for any purpose is hereby granted ++ without fee, provided that\n the above copyright notice appear in ++ all copies and that both that copyright notice and this permission ++ notice appear in supporting documentation, and that the name of ++ the copyright holders not be used in advertising or publicity ++ pertaining to distribution of the software without specific, ++ written prior permission. The copyright holders make no ++ representations about the suitability of this software for any ++ purpose. It is provided "as is" without express or implied ++ warranty. ++ ++ THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS ++ SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND ++ FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY ++ SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES ++ WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN ++ AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ++ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF ++ THIS SOFTWARE. ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ +diff --git a/makefiles/cmake/Wayland.cmake b/makefiles/cmake/Wayland.cmake +new file mode 100644 +index 0000000..ad90d30 +--- /dev/null ++++ b/makefiles/cmake/Wayland.cmake +@@ -0,0 +1,72 @@ ++#============================================================================= ++# Copyright (C) 2012-2013 Pier Luigi Fiorini ++# All rights reserved. ++# ++# Redistribution and use in source and binary forms, with or without ++# modification, are permitted provided that the following conditions ++# are met: ++# ++# * Redistributions of source code must retain the above copyright ++# notice, this list of conditions and the following disclaimer. ++# ++# * Redistributions in binary form must reproduce the above copyright ++# notice, this list of conditions and the following disclaimer in the ++# documentation and/or other materials provided with the distribution. ++# ++# * Neither the name of Pier Luigi Fiorini nor the names of his ++# contributors may be used to endorse or promote products derived ++# from this software without specific prior written permission. ++# ++# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ++# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ++# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ++# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ++# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ++# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ++# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ++#============================================================================= ++ ++find_program(WAYLAND_SCANNER_EXECUTABLE NAMES wayland-scanner) ++ ++# wayland_add_protocol_client(outfiles inputfile basename) ++function(WAYLAND_ADD_PROTOCOL_CLIENT _sources _protocol _basename) ++ if(NOT WAYLAND_SCANNER_EXECUTABLE) ++ message(FATAL "The wayland-scanner executable has nto been found on your system. You must install it.") ++ endif() ++ ++ get_filename_component(_infile ${_protocol} ABSOLUTE) ++ set(_client_header "${CMAKE_CURRENT_BINARY_DIR}/wayland-${_basename}-client-protocol.h") ++ set(_code "${CMAKE_CURRENT_BINARY_DIR}/wayland-${_basename}-protocol.c") ++ ++ add_custom_command(OUTPUT "${_client_header}" ++ COMMAND ${WAYLAND_SCANNER_EXECUTABLE} client-header < ${_infile} > ${_client_header} ++ DEPENDS ${_infile} VERBATIM) ++ ++ add_custom_command(OUTPUT "${_code}" ++ COMMAND ${WAYLAND_SCANNER_EXECUTABLE} code < ${_infile} > ${_code} ++ DEPENDS ${_infile} VERBATIM) ++ ++ list(APPEND ${_sources} "${_client_header}" "${_code}") ++ set(${_sources} ${${_sources}} PARENT_SCOPE) ++endfunction() ++ ++# wayland_add_protocol_server(outfiles inputfile basename) ++function(WAYLAND_ADD_PROTOCOL_SERVER _sources _protocol _basename) ++ if(NOT WAYLAND_SCANNER_EXECUTABLE) ++ message(FATAL "The wayland-scanner executable has nto been found on your system. You must install it.") ++ endif() ++ ++ get_filename_component(_infile ${_protocol} ABSOLUTE) ++ set(_server_header "${CMAKE_CURRENT_BINARY_DIR}/wayland-${_basename}-server-protocol.h") ++ ++ add_custom_command(OUTPUT "${_server_header}" ++ COMMAND ${WAYLAND_SCANNER_EXECUTABLE} server-header < ${_infile} > ${_server_header} ++ DEPENDS ${_infile} VERBATIM) ++ ++ list(APPEND ${_sources} "${_server_header}") ++ set(${_sources} ${${_sources}} PARENT_SCOPE) ++endfunction() +-- +2.19.1 + -- cgit v1.2.1