Linux/AM4379: Wayland demo compilation issues

Ash P

Part Number: AM4379

Tool/software: Linux

H Forum,

I have been facing issues compile demo application. please refer the below source and the issues I am facing.Please suggest me any solution to over come this problem. SDK version ti-processor-sdk-linux-am437x-evm-03.03.00.04-Linux-x86.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <math.h>
#include <assert.h>
#include <signal.h>

#include <linux/input.h>

#include <wayland-client.h>
#include <wayland-client-core.h>
#include <wayland-egl-core.h>
#include <wayland-egl.h>
#include <wayland-cursor.h>

#include <GLES2/gl2.h>
#include <EGL/egl.h>

struct window;
struct seat;

struct display {
    struct wl_display *display;
    struct wl_registry *registry;
    struct wl_compositor *compositor;
    struct wl_shell *shell;
    struct wl_seat *seat;
    struct wl_pointer *pointer;
    struct wl_keyboard *keyboard;
    struct wl_shm *shm;
    struct wl_cursor_theme *cursor_theme;
    struct wl_cursor *default_cursor;
    struct wl_surface *cursor_surface;
    struct {
        EGLDisplay dpy;
        EGLContext ctx;
        EGLConfig conf;
    } egl;
    struct window *window;
};

struct geometry {
    int width, height;
};

struct window {
    struct display *display;
    struct geometry geometry, window_size;
    struct {
        GLuint rotation_uniform;
        GLuint pos;
        GLuint col;
    } gl;

    struct wl_egl_window *native;
    struct wl_surface *surface;
    struct wl_shell_surface *shell_surface;
    EGLSurface egl_surface;
    struct wl_callback *callback;
    int fullscreen, configured, opaque;
};

static const char *vert_shader_text =
    "uniform mat4 rotation;\n"
    "attribute vec4 pos;\n"
    "attribute vec4 color;\n"
    "varying vec4 v_color;\n"
    "void main() {\n"
    "  gl_Position = rotation * pos;\n"
    "  v_color = color;\n"
    "}\n";

static const char *frag_shader_text =
    "precision mediump float;\n"
    "varying vec4 v_color;\n"
    "void main() {\n"
    "  gl_FragColor = v_color;\n"
    "}\n";

static int running = 1;

static void
init_egl(struct display *display, int opaque)
{
    static const EGLint context_attribs[] = {
        EGL_CONTEXT_CLIENT_VERSION, 2,
        EGL_NONE
    };

    EGLint config_attribs[] = {
        EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
        EGL_RED_SIZE, 1,
        EGL_GREEN_SIZE, 1,
        EGL_BLUE_SIZE, 1,
        EGL_ALPHA_SIZE, 1,
        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
        EGL_NONE
    };

    EGLint major, minor, n;
    EGLBoolean ret;

    if (opaque)
        config_attribs[9] = 0;

    display->egl.dpy = eglGetDisplay(display->display);
    assert(display->egl.dpy);

    ret = eglInitialize(display->egl.dpy, &major, &minor);
    assert(ret == EGL_TRUE);
    ret = eglBindAPI(EGL_OPENGL_ES_API);
    assert(ret == EGL_TRUE);

    ret = eglChooseConfig(display->egl.dpy, config_attribs,
                  &display->egl.conf, 1, &n);
    assert(ret && n == 1);

    display->egl.ctx = eglCreateContext(display->egl.dpy,
                        display->egl.conf,
                        EGL_NO_CONTEXT, context_attribs);
    assert(display->egl.ctx);

}

static void
fini_egl(struct display *display)
{
    /* Required, otherwise segfault in egl_dri2.c: dri2_make_current()
     * on eglReleaseThread(). */
    eglMakeCurrent(display->egl.dpy, EGL_NO_SURFACE, EGL_NO_SURFACE,
               EGL_NO_CONTEXT);

    eglTerminate(display->egl.dpy);
    eglReleaseThread();
}

static GLuint
create_shader(struct window *window, const char *source, GLenum shader_type)
{
    GLuint shader;
    GLint status;

    shader = glCreateShader(shader_type);
    assert(shader != 0);

    glShaderSource(shader, 1, (const char **) &source, NULL);
    glCompileShader(shader);

    glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
    if (!status) {
        char log[1000];
        GLsizei len;
        glGetShaderInfoLog(shader, 1000, &len, log);
        fprintf(stderr, "Error: compiling %s: %*s\n",
            shader_type == GL_VERTEX_SHADER ? "vertex" : "fragment",
            len, log);
        exit(1);
    }

    return shader;
}

static void
init_gl(struct window *window)
{
    GLuint frag, vert;
    GLuint program;
    GLint status;

    frag = create_shader(window, frag_shader_text, GL_FRAGMENT_SHADER);
    vert = create_shader(window, vert_shader_text, GL_VERTEX_SHADER);

    program = glCreateProgram();
    glAttachShader(program, frag);
    glAttachShader(program, vert);
    glLinkProgram(program);

    glGetProgramiv(program, GL_LINK_STATUS, &status);
    if (!status) {
        char log[1000];
        GLsizei len;
        glGetProgramInfoLog(program, 1000, &len, log);
        fprintf(stderr, "Error: linking:\n%*s\n", len, log);
        exit(1);
    }

    glUseProgram(program);

    window->gl.pos = 0;
    window->gl.col = 1;

    glBindAttribLocation(program, window->gl.pos, "pos");
    glBindAttribLocation(program, window->gl.col, "color");
    glLinkProgram(program);

    window->gl.rotation_uniform =
        glGetUniformLocation(program, "rotation");
}

static void
handle_ping(void *data, struct wl_shell_surface *shell_surface,
        uint32_t serial)
{
    wl_shell_surface_pong(shell_surface, serial);
}

static void
handle_configure(void *data, struct wl_shell_surface *shell_surface,
         uint32_t edges, int32_t width, int32_t height)
{
    struct window *window = data;

    if (window->native)
        wl_egl_window_resize(window->native, width, height, 0, 0);

    window->geometry.width = width;
    window->geometry.height = height;

    if (!window->fullscreen)
        window->window_size = window->geometry;
}

static void
handle_popup_done(void *data, struct wl_shell_surface *shell_surface)
{
}

static const struct wl_shell_surface_listener shell_surface_listener = {
    handle_ping,
    handle_configure,
    handle_popup_done
};

static void
redraw(void *data, struct wl_callback *callback, uint32_t time);

static void
configure_callback(void *data, struct wl_callback *callback, uint32_t  time)
{
    struct window *window = data;

    wl_callback_destroy(callback);

    window->configured = 1;

    if (window->callback == NULL)
        redraw(data, NULL, time);
}

static struct wl_callback_listener configure_callback_listener = {
    configure_callback,
};

static void
toggle_fullscreen(struct window *window, int fullscreen)
{
    struct wl_callback *callback;

    window->fullscreen = fullscreen;
    window->configured = 0;

    if (fullscreen) {
        wl_shell_surface_set_fullscreen(window->shell_surface,
                        WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT,
                        0, NULL);
    } else {
        wl_shell_surface_set_toplevel(window->shell_surface);
        handle_configure(window, window->shell_surface, 0,
                 window->window_size.width,
                 window->window_size.height);
    }

    callback = wl_display_sync(window->display->display);
    wl_callback_add_listener(callback, &configure_callback_listener,
                 window);
}

static void
create_surface(struct window *window)
{
    struct display *display = window->display;
    EGLBoolean ret;

    window->surface = wl_compositor_create_surface(display->compositor);
    window->shell_surface = wl_shell_get_shell_surface(display->shell,
                               window->surface);

    wl_shell_surface_add_listener(window->shell_surface,
                      &shell_surface_listener, window);

    window->native =
        wl_egl_window_create(window->surface,
                     window->window_size.width,
                     window->window_size.height);
    window->egl_surface =
        eglCreateWindowSurface(display->egl.dpy,
                       display->egl.conf,
                       window->native, NULL);

    wl_shell_surface_set_title(window->shell_surface, "simple-egl");

    ret = eglMakeCurrent(window->display->egl.dpy, window->egl_surface,
                 window->egl_surface, window->display->egl.ctx);
    assert(ret == EGL_TRUE);

    toggle_fullscreen(window, window->fullscreen);
}

static void
destroy_surface(struct window *window)
{
    wl_egl_window_destroy(window->native);

    wl_shell_surface_destroy(window->shell_surface);
    wl_surface_destroy(window->surface);

    if (window->callback)
        wl_callback_destroy(window->callback);
}

static const struct wl_callback_listener frame_listener;

static void
redraw(void *data, struct wl_callback *callback, uint32_t time)
{
    struct window *window = data;
    static const GLfloat verts[3][2] = {
        { -0.5, -0.5 },
        {  0.5, -0.5 },
        {  0,    0.5 }
    };
    static const GLfloat colors[3][3] = {
        { 1, 0, 0 },
        { 0, 1, 0 },
        { 0, 0, 1 }
    };
    GLfloat angle;
    GLfloat rotation[4][4] = {
        { 1, 0, 0, 0 },
        { 0, 1, 0, 0 },
        { 0, 0, 1, 0 },
        { 0, 0, 0, 1 }
    };
    static const int32_t speed_div = 5;
    static uint32_t start_time = 0;
    struct wl_region *region;

    assert(window->callback == callback);
    window->callback = NULL;

    if (callback)
        wl_callback_destroy(callback);

    if (!window->configured)
        return;

    if (start_time == 0)
        start_time = time;

    angle = ((time-start_time) / speed_div) % 360 * M_PI / 180.0;
    rotation[0][0] =  cos(angle);
    rotation[0][2] =  sin(angle);
    rotation[2][0] = -sin(angle);
    rotation[2][2] =  cos(angle);

    glViewport(0, 0, window->geometry.width, window->geometry.height);

    glUniformMatrix4fv(window->gl.rotation_uniform, 1, GL_FALSE,
               (GLfloat *) rotation);

    glClearColor(0.0, 0.0, 0.0, 0.5);
    glClear(GL_COLOR_BUFFER_BIT);

    glVertexAttribPointer(window->gl.pos, 2, GL_FLOAT, GL_FALSE, 0, verts);
    glVertexAttribPointer(window->gl.col, 3, GL_FLOAT, GL_FALSE, 0, colors);
    glEnableVertexAttribArray(window->gl.pos);
    glEnableVertexAttribArray(window->gl.col);

    glDrawArrays(GL_TRIANGLES, 0, 3);

    glDisableVertexAttribArray(window->gl.pos);
    glDisableVertexAttribArray(window->gl.col);

    if (window->opaque || window->fullscreen) {
        region = wl_compositor_create_region(window->display->compositor);
        wl_region_add(region, 0, 0,
                  window->geometry.width,
                  window->geometry.height);
        wl_surface_set_opaque_region(window->surface, region);
        wl_region_destroy(region);
    } else {
        wl_surface_set_opaque_region(window->surface, NULL);
    }

    window->callback = wl_surface_frame(window->surface);
    wl_callback_add_listener(window->callback, &frame_listener, window);

    eglSwapBuffers(window->display->egl.dpy, window->egl_surface);
}

static const struct wl_callback_listener frame_listener = {
    redraw
};

static void
pointer_handle_enter(void *data, struct wl_pointer *pointer,
             uint32_t serial, struct wl_surface *surface,
             wl_fixed_t sx, wl_fixed_t sy)
{
    struct display *display = data;
    struct wl_buffer *buffer;
    struct wl_cursor *cursor = display->default_cursor;
    struct wl_cursor_image *image;

    if (display->window->fullscreen)
        wl_pointer_set_cursor(pointer, serial, NULL, 0, 0);
    else if (cursor) {
        image = display->default_cursor->images[0];
        buffer = wl_cursor_image_get_buffer(image);
        wl_pointer_set_cursor(pointer, serial,
                      display->cursor_surface,
                      image->hotspot_x,
                      image->hotspot_y);
        wl_surface_attach(display->cursor_surface, buffer, 0, 0);
        wl_surface_damage(display->cursor_surface, 0, 0,
                  image->width, image->height);
        wl_surface_commit(display->cursor_surface);
    }
}

static void
pointer_handle_leave(void *data, struct wl_pointer *pointer,
             uint32_t serial, struct wl_surface *surface)
{
}

static void
pointer_handle_motion(void *data, struct wl_pointer *pointer,
              uint32_t time, wl_fixed_t sx, wl_fixed_t sy)
{
}

static void
pointer_handle_button(void *data, struct wl_pointer *wl_pointer,
              uint32_t serial, uint32_t time, uint32_t button,
              uint32_t state)
{
    struct display *display = data;

    if (button == BTN_LEFT && state == WL_POINTER_BUTTON_STATE_PRESSED)
        wl_shell_surface_move(display->window->shell_surface,
                      display->seat, serial);
}

static void
pointer_handle_axis(void *data, struct wl_pointer *wl_pointer,
            uint32_t time, uint32_t axis, wl_fixed_t value)
{
}

static const struct wl_pointer_listener pointer_listener = {
    pointer_handle_enter,
    pointer_handle_leave,
    pointer_handle_motion,
    pointer_handle_button,
    pointer_handle_axis,
};

static void
keyboard_handle_keymap(void *data, struct wl_keyboard *keyboard,
               uint32_t format, int fd, uint32_t size)
{
}

static void
keyboard_handle_enter(void *data, struct wl_keyboard *keyboard,
              uint32_t serial, struct wl_surface *surface,
              struct wl_array *keys)
{
}

static void
keyboard_handle_leave(void *data, struct wl_keyboard *keyboard,
              uint32_t serial, struct wl_surface *surface)
{
}

static void
keyboard_handle_key(void *data, struct wl_keyboard *keyboard,
            uint32_t serial, uint32_t time, uint32_t key,
            uint32_t state)
{
    struct display *d = data;

    if (key == KEY_F11 && state)
        toggle_fullscreen(d->window, d->window->fullscreen ^ 1);
    else if (key == KEY_ESC && state)
        running = 0;
}

static void
keyboard_handle_modifiers(void *data, struct wl_keyboard *keyboard,
              uint32_t serial, uint32_t mods_depressed,
              uint32_t mods_latched, uint32_t mods_locked,
              uint32_t group)
{
}

static const struct wl_keyboard_listener keyboard_listener = {
    keyboard_handle_keymap,
    keyboard_handle_enter,
    keyboard_handle_leave,
    keyboard_handle_key,
    keyboard_handle_modifiers,
};

static void
seat_handle_capabilities(void *data, struct wl_seat *seat,
             enum wl_seat_capability caps)
{
    struct display *d = data;

    if ((caps & WL_SEAT_CAPABILITY_POINTER) && !d->pointer) {
        d->pointer = wl_seat_get_pointer(seat);
        wl_pointer_add_listener(d->pointer, &pointer_listener, d);
    } else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && d->pointer) {
        wl_pointer_destroy(d->pointer);
        d->pointer = NULL;
    }

    if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !d->keyboard) {
        d->keyboard = wl_seat_get_keyboard(seat);
        wl_keyboard_add_listener(d->keyboard, &keyboard_listener, d);
    } else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && d->keyboard) {
        wl_keyboard_destroy(d->keyboard);
        d->keyboard = NULL;
    }
}

static const struct wl_seat_listener seat_listener = {
    seat_handle_capabilities,
};

static void
registry_handle_global(void *data, struct wl_registry *registry,
               uint32_t name, const char *interface, uint32_t version)
{
    struct display *d = data;

    if (strcmp(interface, "wl_compositor") == 0) {
        d->compositor =
            wl_registry_bind(registry, name,
                     &wl_compositor_interface, 1);
    } else if (strcmp(interface, "wl_shell") == 0) {
        d->shell = wl_registry_bind(registry, name,
                        &wl_shell_interface, 1);
    } else if (strcmp(interface, "wl_seat") == 0) {
        d->seat = wl_registry_bind(registry, name,
                       &wl_seat_interface, 1);
        wl_seat_add_listener(d->seat, &seat_listener, d);
    } else if (strcmp(interface, "wl_shm") == 0) {
        d->shm = wl_registry_bind(registry, name,
                      &wl_shm_interface, 1);
        d->cursor_theme = wl_cursor_theme_load(NULL, 32, d->shm);
        d->default_cursor =
            wl_cursor_theme_get_cursor(d->cursor_theme, "left_ptr");
    }
}

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
};

static void
signal_int(int signum)
{
    running = 0;
}

static void
usage(int error_code)
{
    fprintf(stderr, "Usage: simple-egl [OPTIONS]\n\n"
        "  -f\tRun in fullscreen mode\n"
        "  -o\tCreate an opaque surface\n"
        "  -h\tThis help text\n\n");

    exit(error_code);
}

int
main(int argc, char **argv)
{
    struct sigaction sigint;
    struct display display = { 0 };
    struct window  window  = { 0 };
    int i, ret = 0;

    window.display = &display;
    display.window = &window;
    window.window_size.width  = 250;
    window.window_size.height = 250;

    for (i = 1; i < argc; i++) {
        if (strcmp("-f", argv[i]) == 0)
            window.fullscreen = 1;
        else if (strcmp("-o", argv[i]) == 0)
            window.opaque = 1;
        else if (strcmp("-h", argv[i]) == 0)
            usage(EXIT_SUCCESS);
        else
            usage(EXIT_FAILURE);
    }

    display.display = wl_display_connect(NULL);
    assert(display.display);

    display.registry = wl_display_get_registry(display.display);
    wl_registry_add_listener(display.registry,
                 &registry_listener, &display);

    wl_display_dispatch(display.display);

    init_egl(&display, window.opaque);
    create_surface(&window);
    init_gl(&window);

    display.cursor_surface =
        wl_compositor_create_surface(display.compositor);

    sigint.sa_handler = signal_int;
    sigemptyset(&sigint.sa_mask);
    sigint.sa_flags = SA_RESETHAND;
    sigaction(SIGINT, &sigint, NULL);

    while (running && ret != -1)
        ret = wl_display_dispatch(display.display);

    fprintf(stderr, "simple-egl exiting\n");

    destroy_surface(&window);
    fini_egl(&display);

    wl_surface_destroy(display.cursor_surface);
    if (display.cursor_theme)
        wl_cursor_theme_destroy(display.cursor_theme);

    if (display.shell)
        wl_shell_destroy(display.shell);

    if (display.compositor)
        wl_compositor_destroy(display.compositor);

    wl_registry_destroy(display.registry);
    wl_display_flush(display.display);
    wl_display_disconnect(display.display);

    return 0;
}

issues

10:12:30 **** Incremental Build of configuration Debug for project simple ****
make all 
Building target: simple
Invoking: Cross GCC Linker
arm-linux-gnueabihf-gcc  -o "simple"  ./main.o   -lGLES_CM -lEGL -lGLESv2 -lm -lwayland-cursor  -lwayland-client -lwayland-server -lcairo
./main.o: In function `handle_configure':
/home/alpha/workspace_v7/simple/Debug/../main.c:223: undefined reference to `wl_egl_window_resize'
makefile:35: recipe for target 'simple' failed
./main.o: In function `create_surface':
/home/alpha/workspace_v7/simple/Debug/../main.c:301: undefined reference to `wl_egl_window_create'
./main.o: In function `destroy_surface':
/home/alpha/workspace_v7/simple/Debug/../main.c:321: undefined reference to `wl_egl_window_destroy'
collect2: error: ld returned 1 exit status
make: *** [simple] Error 1

Any Suggestions will be appreciated.

Regards

-Parker

over 8 years ago

0 Biser Gatchev-XID over 8 years ago

TI__Guru**** 393215 points

The software team have been notified. They will respond here.

0 Ramprasad over 8 years ago in reply to Biser Gatchev-XID

TI__Mastermind 30480 points

Can you add -lpvr_wlegl to library list and try

0 Ash P over 8 years ago in reply to Ramprasad

Expert 1570 points

Thanks that solved the problem

0 Ash P over 8 years ago

Expert 1570 points

Part Number: AM4379

Tool/software: Linux

Hi Forums,

Where can i download the demo source code for all the weston demos that i can find in the /usr/bin folder in my file system ?? how do i compile and build them using sitara sdk and CCS ??

Regards

-Parker

0 Ash P over 8 years ago in reply to Ramprasad

Expert 1570 points

Hi Ramprasad,
Do you have any more information on my question ??
Regards
-Parker

0 Ramprasad over 8 years ago in reply to Ash P

TI__Mastermind 30480 points

Hi Parker,
You need to build yocto for this. Source code for all weston client examples can be found here.
cgit.freedesktop.org/.../

But there are many dependencies to build them, so Yocto building works.

Check if you can build using
wayland.freedesktop.org/building.html

0 Ash P over 8 years ago in reply to Ramprasad

Expert 1570 points

so I cant build and run weston examples using sitara sdk using code composer studio and deploy on arago build?? is my understanding correct or am i missing something ??

0 Ramprasad over 8 years ago in reply to Ash P

TI__Mastermind 30480 points

You can't use CCS to build weston examples. If you are on SDK 3.02 or 3.03, refer this
processors.wiki.ti.com/.../DRA7xx_GLSDK_Software_Developers_Guide

Yocto will get you access to all component's soruce code and you can modify any component and rebuild

0 Ash P over 8 years ago in reply to Ramprasad

Expert 1570 points

I need to implement an on screen display using video overlay what would be the best possible approach i could take in order to achieve this. this is for a video application and i need the onscreen display to overlay on the live video any suggestions will be welcome.

Regards
-Parker

0 Ash P over 8 years ago in reply to Ramprasad

Expert 1570 points

to add further i would like the osd to be scalable. I would also like to use PNG images to build the osd. or may be use a psd ??

0 Ramprasad over 8 years ago in reply to Ash P

TI__Mastermind 30480 points

Hi Parker,
I could not understand your usecase fully. Can you give more details? Are you planning to use weston/wayland only for overlaying the video ?

0 Ash P over 8 years ago in reply to Ramprasad

Expert 1570 points

Hi Ramprasad,

I would like to run a ui this ui will be controlled using the push buttons on the am437xgpevm eval board. this ui will be overlayed on the dual camera application. the ui will allow the user to select the area on the live camera feed coming in where the user gives a hstart hend vstart vend. so that a rectangle is overlayed on the live camera feed. then we do some image processing on that selected area. this is the sample use case. I would like to use some attractive ui or a user interface kit to do the generate the menus.

regards
-Parker

Processors

Processors forum

Linux/AM4379: Wayland demo compilation issues