LayerManagerExamples: Add Example application for chromakey

7 files changed, 915 insertions, 0 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6898aaa..ec66e24 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -143,6 +143,7 @@ endif(WITH_CLIENTEXAMPLES)
 if (WITH_WL_EXAMPLE)
     add_subdirectory (LayerManagerExamples/EGLWLApplicationExample)
     add_subdirectory (LayerManagerExamples/EGLWLMockNavigation)
+    add_subdirectory (LayerManagerExamples/WLChromakeyExample)
 endif(WITH_WL_EXAMPLE)
 
 # enable ctest if building with tests
diff --git a/LayerManagerExamples/WLChromakeyExample/CMakeLists.txt b/LayerManagerExamples/WLChromakeyExample/CMakeLists.txt
new file mode 100644
index 0000000..9d0b202
--- /dev/null
+++ b/LayerManagerExamples/WLChromakeyExample/CMakeLists.txt
@@ -0,0 +1,71 @@
+############################################################################
+#
+# Copyright 2010-2012 BMW Car IT GmbH
+# Copyright (C) 2011 DENSO CORPORATION and Robert Bosch Car Multimedia Gmbh
+#
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#		http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+############################################################################
+
+cmake_minimum_required (VERSION 2.6)
+
+find_package(GLESv2 REQUIRED)
+find_package(EGL REQUIRED)
+find_package(Wayland REQUIRED)
+
+include_directories(
+    ${GLESv2_INCLUDE_DIR}
+    ${EGL_INCLUDE_DIR}
+    ${WAYLAND_CLIENT_INCLUDE_DIR}
+    ${FFI_INCLUDE_DIR}
+    "include"
+    "../../LayerManagerClient/ilmClient/include"
+    "../../LayerManagerUtils/include"
+)
+
+set (HEADER_FILES
+	include/bmpaccessor.h
+	include/serverinfo-client-protocol.h
+)
+
+set (SRC_FILES
+	src/chromakey.c
+	src/bmpaccessor.c
+)
+
+add_executable(WLChromakeyExample
+    ${SRC_FILES}
+    ${HEADER_FILES}
+)
+
+add_dependencies(WLChromakeyExample
+    wayland-client
+    ilmClient
+    LayerManagerUtils
+)
+
+set(LIBS
+	${LIBS}
+	${GLESv2_LIBRARIES}
+	${WAYLAND_CLIENT_LIBRARIES}
+    ${WAYLAND_EGL_LIBRARIES}
+    ${FFI_LIBRARIES}
+	${EGL_LIBRARY}
+	LayerManagerUtils
+	ilmClient
+)
+
+target_link_libraries(WLChromakeyExample ${LIBS})
+
+install (TARGETS WLChromakeyExample DESTINATION bin)
diff --git a/LayerManagerExamples/WLChromakeyExample/include/bmpaccessor.h b/LayerManagerExamples/WLChromakeyExample/include/bmpaccessor.h
new file mode 100644
index 0000000..0ef5d98
--- /dev/null
+++ b/LayerManagerExamples/WLChromakeyExample/include/bmpaccessor.h
@@ -0,0 +1,36 @@
+/***************************************************************************
+ *
+ * Copyright 2010,2011 BMW Car IT GmbH
+ * Copyright (C) 2012 DENSO CORPORATION and Robert Bosch Car Multimedia Gmbh
+ *
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ ****************************************************************************/
+#ifndef _BMPACCESSOR_H_
+#define _BMPACCESSOR_H_
+
+typedef struct _ctx_bmpaccessor {
+    void*          data;
+    unsigned short width;
+    unsigned short height;
+    unsigned short stride;
+    unsigned short strideOrg;
+    unsigned char  bitCount;
+    unsigned char  bitCountOrg;
+} ctx_bmpaccessor;
+
+ctx_bmpaccessor* bmpaccessor_open(unsigned char* path);
+void bmpaccessor_close(ctx_bmpaccessor* ctx);
+
+#endif /* _BMPACCESSOR_H_ */
diff --git a/LayerManagerExamples/WLChromakeyExample/include/serverinfo-client-protocol.h b/LayerManagerExamples/WLChromakeyExample/include/serverinfo-client-protocol.h
new file mode 100644
index 0000000..a68358e
--- /dev/null
+++ b/LayerManagerExamples/WLChromakeyExample/include/serverinfo-client-protocol.h
@@ -0,0 +1,87 @@
+/***************************************************************************
+ *
+ * Copyright 2010,2011 BMW Car IT GmbH
+ * Copyright (C) 2012 DENSO CORPORATION and Robert Bosch Car Multimedia Gmbh
+ *
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ ****************************************************************************/
+#ifndef SERVERINFO_CLIENT_PROTOCOL_H
+#define SERVERINFO_CLIENT_PROTOCOL_H
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <stddef.h>
+#include "wayland-util.h"
+
+struct wl_client;
+struct wl_resource;
+
+struct serverinfo;
+
+extern const struct wl_interface serverinfo_interface;
+
+struct serverinfo_listener {
+	/**
+	 * connection_id - (none)
+	 * @connection_id: (none)
+	 */
+	void (*connection_id)(void *data,
+			      struct serverinfo *serverinfo,
+			      uint32_t connection_id);
+};
+
+static inline int
+serverinfo_add_listener(struct serverinfo *serverinfo,
+			const struct serverinfo_listener *listener, void *data)
+{
+	return wl_proxy_add_listener((struct wl_proxy *) serverinfo,
+				     (void (**)(void)) listener, data);
+}
+
+#define SERVERINFO_GET_CONNECTION_ID	0
+
+static inline void
+serverinfo_set_user_data(struct serverinfo *serverinfo, void *user_data)
+{
+	wl_proxy_set_user_data((struct wl_proxy *) serverinfo, user_data);
+}
+
+static inline void *
+serverinfo_get_user_data(struct serverinfo *serverinfo)
+{
+	return wl_proxy_get_user_data((struct wl_proxy *) serverinfo);
+}
+
+static inline void
+serverinfo_destroy(struct serverinfo *serverinfo)
+{
+	wl_proxy_destroy((struct wl_proxy *) serverinfo);
+}
+
+static inline void
+serverinfo_get_connection_id(struct serverinfo *serverinfo)
+{
+	wl_proxy_marshal((struct wl_proxy *) serverinfo,
+			 SERVERINFO_GET_CONNECTION_ID);
+}
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif /* SERVERINFO_CLIENT_PROTOCOL_H */
diff --git a/LayerManagerExamples/WLChromakeyExample/src/bmpaccessor.c b/LayerManagerExamples/WLChromakeyExample/src/bmpaccessor.c
new file mode 100644
index 0000000..7e5387c
--- /dev/null
+++ b/LayerManagerExamples/WLChromakeyExample/src/bmpaccessor.c
@@ -0,0 +1,221 @@
+/***************************************************************************
+ *
+ * Copyright 2010,2011 BMW Car IT GmbH
+ * Copyright (C) 2012 DENSO CORPORATION and Robert Bosch Car Multimedia Gmbh
+ *
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ ****************************************************************************/
+#include <stdio.h>
+#include <stdlib.h>
+#include "bmpaccessor.h"
+
+typedef struct _BITMAPFILEHEADER {
+    unsigned short bfType;
+    unsigned int   bfSize;
+    unsigned short bfReserved1;
+    unsigned short bfReserved2;
+    unsigned int   bfOffBits;
+} BITMAPFILEHEADER;
+
+typedef struct _BITMAPINFOHEADER {
+    unsigned int   biSize;
+    int            biWidth;
+    int            biHeight;
+    unsigned short biPlanes;
+    unsigned short biBitCount;
+    unsigned int   biCompression;
+    unsigned int   biSizeImage;
+    int            biXPixPerMeter;
+    int            biYPixPerMeter;
+    unsigned int   biClrUsed;
+    unsigned int   biClrImporant;
+} BITMAPINFOHEADER;
+
+/**
+ *  \brief Open windows bitmap file
+ *  \param[in] bitmap file path
+ *  \return context of bmpaccessor
+*/
+ctx_bmpaccessor* bmpaccessor_open(unsigned char* path)
+{
+    FILE* fp;
+    ctx_bmpaccessor* ctx = NULL;
+    BITMAPFILEHEADER file_head;
+    BITMAPINFOHEADER info_head;
+    size_t read_num = 0;
+    unsigned char* p_in = NULL;
+    unsigned char* p_in_pnt = NULL;
+    unsigned char* p_out_pnt = NULL;
+    int cntX = 0;
+    int cntY = 0;
+
+    do
+    {
+        fp = fopen(path, "rb");
+        if (fp == NULL)
+        {
+            printf("failed to open %s\n", path);
+            break;
+        }
+
+        ctx = (ctx_bmpaccessor*)malloc(sizeof(ctx_bmpaccessor));
+        if (NULL == ctx)
+        {
+            printf("failed to allocate context\n");
+            break;
+        }
+
+        read_num = fread(&file_head.bfType, sizeof(unsigned short), 1, fp);
+        if (read_num != 1)
+        {
+            printf("failed to read bfType\n");
+            break;
+        }
+        read_num = fread(&file_head.bfSize, sizeof(unsigned int), 2, fp);
+        if (read_num != 2)
+        {
+            printf("failed to read bfSize\n");
+            break;
+        }
+        read_num = fread(&file_head.bfOffBits, sizeof(unsigned int), 1, fp);
+        if (read_num != 1)
+        {
+            printf("failed to read bfOffBits\n");
+            break;
+        }
+        printf("bfSize   : %d(0x%x)\n", file_head.bfSize,    file_head.bfSize);
+        printf("bfOffBits: %d(0x%x)\n", file_head.bfOffBits, file_head.bfOffBits);
+
+        read_num = fread(&info_head.biSize, sizeof(unsigned int), 1, fp);
+        if (read_num != 1)
+        {
+            printf("failed to read biSize\n");
+            break;
+        }
+        read_num = fread(&info_head.biWidth, sizeof(unsigned int), 2, fp);
+        if (read_num != 2)
+        {
+            printf("failed to read image size\n");
+            break;
+        }
+        read_num = fread(&info_head.biPlanes, sizeof(unsigned short), 2, fp);
+        if (read_num != 2)
+        {
+            printf("failed to read biBitCount\n");
+            break;
+        }
+
+        printf("biSize   : %d(0x%x)\n", info_head.biSize,     info_head.biSize);
+        printf("biWidth  : %d(0x%x)\n", info_head.biWidth,    info_head.biWidth);
+        printf("biHeight : %d(0x%x)\n", info_head.biHeight,   info_head.biHeight);
+        printf("bitCount : %d(0x%x)\n", info_head.biBitCount, info_head.biBitCount);
+
+        ctx->bitCountOrg = (info_head.biBitCount>>3);
+        ctx->bitCount = 4;
+        if (0 >= ctx->bitCountOrg)
+        {
+            printf("support bitCounts is only 24BPP with non-compression\n");
+            break;
+        }
+        ctx->width  = info_head.biWidth;
+        if (0 > info_head.biHeight)
+        {
+            ctx->height = -info_head.biHeight;
+        }
+        else
+        {
+            ctx->height = info_head.biHeight;
+        }
+        ctx->strideOrg = ctx->width * ctx->bitCountOrg;
+        ctx->stride = (ctx->width<<2);
+        p_in = (void*)malloc(ctx->strideOrg * ctx->height);
+        if (NULL == p_in)
+        {
+            printf("failed to allocate work memory\n");
+            break;
+        }
+        ctx->data = (void*)malloc(ctx->stride * ctx->height);
+        if (NULL == ctx->data)
+        {
+            printf("failed to allocate image memory\n");
+            break;
+        }
+        fseek(fp, file_head.bfOffBits, SEEK_SET);
+        read_num = fread(p_in, ctx->strideOrg * ctx->height, 1, fp);
+        if (read_num != 1)
+        {
+            printf("failed to read header\n");
+            break;
+        }
+        p_in_pnt = p_in;
+        p_out_pnt = ctx->data;
+        for (cntY = 0; cntY < ctx->height; cntY++)
+        {
+            p_out_pnt = (unsigned char*)ctx->data + (ctx->height - cntY - 1) * ctx->stride;
+            for (cntX = 0; cntX < ctx->width; cntX++)
+            {
+                *(p_out_pnt + 0) = *(p_in_pnt + 0);
+                *(p_out_pnt + 1) = *(p_in_pnt + 1);
+                *(p_out_pnt + 2) = *(p_in_pnt + 2);
+                //*(p_out_pnt + 3) = 0;
+                *(p_out_pnt + 3) = 0xFF;
+                p_out_pnt += 4;
+                p_in_pnt += 3;
+            }
+        }
+
+        free(p_in);
+        fclose(fp);
+
+        printf("%s is %d x %d\n", path, ctx->width, ctx->height);
+
+        return ctx;
+
+    } while(0);
+
+    if (NULL != ctx)
+    {
+        free(ctx);
+    }
+    if (NULL != p_in)
+    {
+        free(p_in);
+    }
+    if (NULL != fp)
+    {
+        fclose(fp);
+    }
+
+    return NULL;
+}
+
+/**
+ *  \brief Close windows bitmap file
+ *  \param[in] context of bmpaccessor_open
+*/
+void bmpaccessor_close(ctx_bmpaccessor* ctx)
+{
+    if (NULL == ctx)
+    {
+         return;
+    }
+    if (NULL != ctx->data)
+    {
+        free(ctx->data);
+    }
+    free(ctx);
+}
+
+/* End of File */
diff --git a/LayerManagerExamples/WLChromakeyExample/src/chromakey.c b/LayerManagerExamples/WLChromakeyExample/src/chromakey.c
new file mode 100644
index 0000000..589c955
--- /dev/null
+++ b/LayerManagerExamples/WLChromakeyExample/src/chromakey.c
@@ -0,0 +1,459 @@
+/***************************************************************************
+ *
+ * Copyright 2010,2011 BMW Car IT GmbH
+ * Copyright (C) 2012 DENSO CORPORATION and Robert Bosch Car Multimedia Gmbh
+ *
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ ****************************************************************************/
+#include "wayland-client.h"
+#include "wayland-client-protocol.h"
+#include "ilm/ilm_client.h"
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <getopt.h>
+
+#include "serverinfo-client-protocol.h"
+#include "serverinfo-protocol.c"
+
+#include "bmpaccessor.h"
+
+/*****************************************************************************
+ *  local defines
+ ****************************************************************************/
+#define LAYER_CHROMAKEY   3500
+#define SURFACE_CHROMAKEY 6789
+
+#define CHECK_ILM_ERROR(S)		\
+	if ((S) != ILM_SUCCESS){	\
+		printf("%s (%d): ilm command failed.\n", __FILE__, __LINE__); \
+		break;					\
+	}							\
+
+/*****************************************************************************
+ *  structure
+ ****************************************************************************/
+typedef struct t_wlContextStruct {
+    struct wl_display*    wlDisplay;
+    struct wl_compositor* wlCompositor;
+    struct wl_surface*    wlSurface;
+    struct wl_shm*        wlShm;
+    uint32_t              formats;
+    uint32_t              mask;
+    struct serverinfo*    wlExtServerinfo;
+    uint32_t              connect_id;
+    ctx_bmpaccessor*      ctx_bmp;
+    void*                 data;
+    struct wl_buffer*     wlBuffer;
+} WLContextStruct;
+
+/*****************************************************************************
+ *  globals
+ ****************************************************************************/
+WLContextStruct g_wlContextStruct;
+int gRun = 0;
+
+static void serverinfoListener(void *data, struct serverinfo *pServerinfo, uint32_t client_handle)
+{
+    WLContextStruct* p_wlCtx = (WLContextStruct*)data;
+    p_wlCtx->connect_id = client_handle;
+}
+
+struct serverinfo_listener serverinfo_listener_list = {
+    serverinfoListener
+};
+
+static void shm_format(void* data, struct wl_shm* pWlShm, uint32_t format)
+{
+    WLContextStruct* pDsp = data;
+    pDsp->formats |= (1 << format);
+}
+
+struct wl_shm_listener shm_listenter = {
+    shm_format
+};
+
+static void display_handle_global(struct wl_display* display, uint32_t id, const char* interface, uint32_t version, void* data)
+{
+    WLContextStruct* p_wlCtx = (WLContextStruct*)data;
+    int ans_strcmp = 0;
+
+    do
+    {
+        ans_strcmp = strcmp(interface, "wl_compositor");
+        if (0 == ans_strcmp)
+        {
+            p_wlCtx->wlCompositor = (struct wl_compositor*)wl_display_bind(display, id, &wl_compositor_interface);
+            break;
+        }
+
+        ans_strcmp = strcmp(interface, "wl_shm");
+        if (0 == ans_strcmp)
+        {
+            p_wlCtx->wlShm = wl_display_bind(display, id, &wl_shm_interface);
+            wl_shm_add_listener(p_wlCtx->wlShm, &shm_listenter, p_wlCtx);
+            break;
+        }
+
+        ans_strcmp = strcmp(interface, "serverinfo");
+        if (0 == ans_strcmp)
+        {
+            p_wlCtx->wlExtServerinfo = (struct serverinfo*)wl_display_bind(display, id, &serverinfo_interface);
+            serverinfo_add_listener(p_wlCtx->wlExtServerinfo, &serverinfo_listener_list, data);
+            serverinfo_get_connection_id(p_wlCtx->wlExtServerinfo);
+        }
+    } while(0);
+}
+
+static int
+event_mask_update(uint32_t mask, void* data)
+{
+    WLContextStruct* p_wlCtx = (WLContextStruct*)data;
+    p_wlCtx->mask = mask;
+    return 0;
+}
+
+/*****************************************************************************
+ *  local functions
+ ****************************************************************************/
+static void createShmBuffer()
+{
+    char filename[] = "/tmp/wayland-shm-XXXXXX";
+    int fd = -1;
+    int size = 0;
+
+    fd = mkstemp(filename);
+    if (fd < 0){
+        fprintf(stderr, "open %s failed: %m\n", filename);
+        return;
+    }
+    size = g_wlContextStruct.ctx_bmp->stride * g_wlContextStruct.ctx_bmp->height;
+    if (ftruncate(fd, size) < 0){
+        fprintf(stderr, "ftruncate failed: %m\n");
+        close(fd);
+        return;
+    }
+
+    g_wlContextStruct.data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+
+    if (MAP_FAILED == g_wlContextStruct.data)
+    {
+        fprintf(stderr, "mmap failed: %m\n");
+        close(fd);
+        return;
+    }
+
+    g_wlContextStruct.wlBuffer = wl_shm_create_buffer(g_wlContextStruct.wlShm,
+                                                      fd,
+                                                      g_wlContextStruct.ctx_bmp->width,
+                                                      g_wlContextStruct.ctx_bmp->height,
+                                                      g_wlContextStruct.ctx_bmp->stride,
+                                                      WL_SHM_FORMAT_XRGB8888);
+    if (NULL == g_wlContextStruct.wlBuffer)
+    {
+        fprintf(stderr, "wl_shm_create_buffer failed: %m\n");
+        close(fd);
+        return;
+    }
+    wl_surface_attach(g_wlContextStruct.wlSurface, g_wlContextStruct.wlBuffer, 0, 0);
+
+    close(fd);
+
+    return;
+}
+
+static void destroyWLContext()
+{
+    if (g_wlContextStruct.wlSurface)
+    {
+        wl_surface_destroy(g_wlContextStruct.wlSurface);
+    }
+    if (g_wlContextStruct.wlCompositor)
+    {
+        wl_compositor_destroy(g_wlContextStruct.wlCompositor);
+    }
+}
+
+static int createWLContext()
+{
+    t_ilm_bool result = ILM_TRUE;
+
+    g_wlContextStruct.wlDisplay = wl_display_connect(NULL);
+    if (NULL == g_wlContextStruct.wlDisplay)
+    {
+        printf("Error: wl_display_connect() failed.\n");
+    }
+
+    wl_display_add_global_listener(g_wlContextStruct.wlDisplay, display_handle_global, &g_wlContextStruct);
+    wl_display_get_fd(g_wlContextStruct.wlDisplay, event_mask_update, &g_wlContextStruct);
+    wl_display_iterate(g_wlContextStruct.wlDisplay, WL_DISPLAY_READABLE);
+    wl_display_roundtrip(g_wlContextStruct.wlDisplay);
+
+    g_wlContextStruct.wlSurface = wl_compositor_create_surface(g_wlContextStruct.wlCompositor);
+    if (NULL == g_wlContextStruct.wlSurface)
+    {
+        printf("Error: wl_compositor_create_surface failed.\n");
+        destroyWLContext();
+    }
+
+    createShmBuffer();
+
+    return result;
+}
+
+static void frame_listener_func(void *data, struct wl_callback *callback, uint32_t time)
+{
+    if (callback)
+    {
+        wl_callback_destroy(callback);
+    }
+}
+
+static const struct wl_callback_listener frame_listener = {
+    frame_listener_func
+};
+
+static void drawImage(void)
+{
+    memcpy(g_wlContextStruct.data,
+           g_wlContextStruct.ctx_bmp->data,
+           g_wlContextStruct.ctx_bmp->stride * g_wlContextStruct.ctx_bmp->height);
+
+    wl_buffer_damage(g_wlContextStruct.wlBuffer,
+                     0, 0,
+                     g_wlContextStruct.ctx_bmp->width,
+                     g_wlContextStruct.ctx_bmp->height);
+    wl_surface_attach(g_wlContextStruct.wlSurface,
+                      g_wlContextStruct.wlBuffer,
+                      0, 0);
+    wl_surface_damage(g_wlContextStruct.wlSurface,
+                      0, 0,
+                      g_wlContextStruct.ctx_bmp->width,
+                      g_wlContextStruct.ctx_bmp->height);
+    struct wl_callback* callback = wl_surface_frame(g_wlContextStruct.wlSurface);
+    wl_callback_add_listener(callback, &frame_listener, NULL);
+    //wl_display_flush(g_wlContextStruct.wlDisplay);
+    wl_display_roundtrip(g_wlContextStruct.wlDisplay);
+}
+
+static ilmErrorTypes createILMAttribute(t_ilm_layer *pLayerId, t_ilm_surface *pSurfaceId, unsigned int colorkey[])
+{
+    ilmErrorTypes error = ILM_FAILED;
+    t_ilm_layer   layerid   = *pLayerId;
+    t_ilm_surface surfaceid = *pSurfaceId;
+
+    do {
+        printf("Creating Layer... ");
+        error = ilm_layerCreateWithDimension(&layerid,
+                                             g_wlContextStruct.ctx_bmp->width,
+                                             g_wlContextStruct.ctx_bmp->height);
+        CHECK_ILM_ERROR(error);
+
+        printf("Setting Layer destination rectangle(0, 0, %d, %d)... \n",
+            g_wlContextStruct.ctx_bmp->width,
+            g_wlContextStruct.ctx_bmp->height);
+        error = ilm_layerSetDestinationRectangle(layerid,
+                                                 0, 0,
+                                                 g_wlContextStruct.ctx_bmp->width,
+                                                 g_wlContextStruct.ctx_bmp->height);
+        CHECK_ILM_ERROR(error);
+
+        printf("Setting Layer source rectangle(0, 0, %d, %d)... \n",
+            g_wlContextStruct.ctx_bmp->width,
+            g_wlContextStruct.ctx_bmp->height);
+        error = ilm_layerSetSourceRectangle(layerid,
+                                            0, 0,
+                                            g_wlContextStruct.ctx_bmp->width,
+                                            g_wlContextStruct.ctx_bmp->height);
+        CHECK_ILM_ERROR(error);
+
+        printf("Setting Layer visibility(%d)... \n", 1);
+        error = ilm_layerSetVisibility(layerid, ILM_TRUE);
+        CHECK_ILM_ERROR(error);
+
+        error = ilm_layerSetOpacity(layerid, 1.0f);
+        CHECK_ILM_ERROR(error);
+
+        struct wl_object* p_obj = (struct wl_object*)g_wlContextStruct.wlSurface;
+        t_ilm_nativehandle native_ilm_handle = (g_wlContextStruct.connect_id << 16) | (uint32_t)p_obj->id;
+        error = ilm_surfaceCreate(native_ilm_handle,
+                                  g_wlContextStruct.ctx_bmp->width,
+                                  g_wlContextStruct.ctx_bmp->height,
+                                  ILM_PIXELFORMAT_RGBA_8888,
+                                  &surfaceid);
+        CHECK_ILM_ERROR(error);
+
+        printf("set surface dest region\n");
+        error = ilm_surfaceSetDestinationRectangle(surfaceid,
+                                                   0, 0,
+                                                   g_wlContextStruct.ctx_bmp->width,
+                                                   g_wlContextStruct.ctx_bmp->height);
+        CHECK_ILM_ERROR(error);
+
+
+        printf("set surface src region\n");
+        error = ilm_surfaceSetSourceRectangle(surfaceid,
+                                              0, 0,
+                                              g_wlContextStruct.ctx_bmp->width,
+                                              g_wlContextStruct.ctx_bmp->height);
+        CHECK_ILM_ERROR(error);
+
+
+        printf("add surface to layer\n");
+        error = ilm_layerAddSurface(layerid, surfaceid);
+        CHECK_ILM_ERROR(error);
+
+        printf("Set surface visible\n");
+        error = ilm_surfaceSetVisibility(surfaceid, ILM_TRUE);
+        CHECK_ILM_ERROR(error);
+
+        printf("Set surface opacity\n");
+        error = ilm_surfaceSetOpacity(surfaceid, 0.7f);
+        CHECK_ILM_ERROR(error);
+
+        printf("Set surface chromakey\n");
+        //unsigned int col[3] = {255, 242, 0};
+        error = ilm_surfaceSetChromaKey(surfaceid, colorkey);
+        CHECK_ILM_ERROR(error);
+
+        printf("commit\n");
+        error = ilm_commitChanges();
+        CHECK_ILM_ERROR(error);
+
+    } while (0);
+
+    *pLayerId   = layerid;
+    *pSurfaceId = surfaceid;
+
+    return error;
+}
+
+static void sigFunc()
+{
+    printf("Catch signal\n");
+    gRun = 0;
+}
+
+static void print_usage()
+{
+    printf("Usage: WLChromakeyExample -f [BITMAP FILE] -c [R,G,B]\n");
+    printf("Chromakey for surface example (wayland backend).\n");
+    printf("\n");
+    printf("Option:\n");
+    printf("-f, --file=FILE            bitmap file of uncompressed RGB888(24BPP) format\n");
+    printf("-c, --color=COLOR(R,G,B)   color value which defines the transparency value\n");
+    printf("                           default values are 255,255,255\n");
+}
+
+/*****************************************************************************
+ *  exported functions
+ ****************************************************************************/
+
+int main(int argc, char *argv[])
+{
+    ilmErrorTypes result = ILM_FAILED;
+    t_ilm_layer layerid = (t_ilm_layer)LAYER_CHROMAKEY;
+    t_ilm_surface surfaceid = (t_ilm_surface)SURFACE_CHROMAKEY;
+    char* bitmapFile = NULL;
+    int o;
+    static const char opts[] = "f:c:h";
+    static const struct option longopts[] = {
+        { "file",  1, NULL, 'f' },
+        { "color", 1, NULL, 'c' },
+        { "help",  1, NULL, 'h' },
+        { NULL, }
+    };
+    unsigned int rgb[] = {255, 255, 255}; /* Default color key is 'White' */
+
+    while (o = getopt_long(argc, argv, opts, longopts, &o), o > 0) {
+        switch (o) {
+        case 'f':
+            bitmapFile = optarg;
+            break;
+        case 'c':
+            sscanf(optarg, "%d,%d,%d", &rgb[0], &rgb[1], &rgb[2]);
+            break;
+        case 'h':
+            print_usage();
+            return 0;
+        }
+    }
+
+    if (bitmapFile == NULL) {
+        print_usage();
+        return -1;
+    }
+
+    printf("[INFO] bitmap file = %s\n", bitmapFile);
+    printf("[INFO] color key   = R(%d),G(%d),B(%d)\n", rgb[0], rgb[1], rgb[2]);
+
+    /* signal handling */
+    signal(SIGINT,  sigFunc);
+    signal(SIGKILL, sigFunc);
+
+    gRun = 1;
+    memset(&g_wlContextStruct, 0x00, sizeof(g_wlContextStruct));
+
+    g_wlContextStruct.ctx_bmp = bmpaccessor_open(bitmapFile);
+    if (NULL == g_wlContextStruct.ctx_bmp)
+    {
+        printf("Failed to create bmp accessor\n");
+        return -1;
+    }
+
+    do {
+        createWLContext();
+
+        result = ilm_init();
+        if (ILM_SUCCESS == result)
+        {
+            printf("ilm_init success\n");
+        }
+        else
+        {
+            printf("ilm_init failed\n");
+            break;
+        }
+        result = createILMAttribute(&layerid, &surfaceid, rgb);
+        if (result != ILM_SUCCESS)
+        {
+            break;
+        }
+
+        t_ilm_layer layer[] = {1000, 2000, 3000, LAYER_CHROMAKEY};
+        ilm_displaySetRenderOrder(0, &layer[0], 4);
+
+        ilm_commitChanges();
+
+        while(gRun) {
+            drawImage();
+        }
+
+        ilm_surfaceRemove(surfaceid);
+        ilm_layerRemove(layerid);
+    } while(0);
+
+    ilm_destroy();
+    destroyWLContext();
+
+    bmpaccessor_close(g_wlContextStruct.ctx_bmp);
+
+    return 0;
+}
diff --git a/LayerManagerExamples/WLChromakeyExample/src/serverinfo-protocol.c b/LayerManagerExamples/WLChromakeyExample/src/serverinfo-protocol.c
new file mode 100644
index 0000000..98974d6
--- /dev/null
+++ b/LayerManagerExamples/WLChromakeyExample/src/serverinfo-protocol.c
@@ -0,0 +1,40 @@
+/***************************************************************************
+ *
+ * Copyright 2010,2011 BMW Car IT GmbH
+ * Copyright (C) 2012 DENSO CORPORATION and Robert Bosch Car Multimedia Gmbh
+ *
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ ****************************************************************************/
+#include <stdlib.h>
+#include <stdint.h>
+#include "wayland-util.h"
+
+static const struct wl_interface *types[] = {
+	NULL,
+};
+
+static const struct wl_message serverinfo_requests[] = {
+	{ "get_connection_id", "", types + 0 },
+};
+
+static const struct wl_message serverinfo_events[] = {
+	{ "connection_id", "u", types + 0 },
+};
+
+WL_EXPORT const struct wl_interface serverinfo_interface = {
+	"serverinfo", 1,
+	ARRAY_LENGTH(serverinfo_requests), serverinfo_requests,
+	ARRAY_LENGTH(serverinfo_events), serverinfo_events,
+};