tests/test-common.c

   1 /*
   2  * Copyright © 2013 TOYOTA MOTOR CORPORATION
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and its
   5  * documentation for any purpose is hereby granted without fee, provided that
   6  * the above copyright notice appear in all copies and that both that copyright
   7  * notice and this permission notice appear in supporting documentation, and
   8  * that the name of the copyright holders not be used in advertising or
   9  * publicity pertaining to distribution of the software without specific,
  10  * written prior permission.  The copyright holders make no representations
  11  * about the suitability of this software for any purpose.  It is provided "as
  12  * is" without express or implied warranty.
  13  *
  14  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  15  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  16  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  17  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  18  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  19  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  20  * OF THIS SOFTWARE.
  21  */
  22 /**
  23  * @brief   Uint test common routines
  24  *
  25  * @date    Feb-08-2013
  26  */
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <unistd.h>
  32 #include <sys/ioctl.h>
  33 #include <sys/time.h>
  34 #include <sys/types.h>
  35 #include <time.h>
  36 #include <errno.h>
  37 #include <wayland-client.h>
  38 #include "ico_window_mgr-client-protocol.h"
  39 #include "test-common.h"
  40
  41 /*--------------------------------------------------------------------------*/
  42 /**
  43  * @brief   getdata: Input data string
  44  *
  45  * @param[in]   window_mgr  ico_window_mgr, if Null, output to stderr
  46  * @param[in]   prompt      Echoback printout header
  47  * @param[in]   fd          Input file discriptor
  48  * @param[in]   buf         Input buffer
  49  * @param[in]   size        Buffer size
  50  * @return      Number of input characters
  51  * @retval      >= 0        Number of input characters
  52  * @retval      < 0         Input error
  53  */
  54 /*--------------------------------------------------------------------------*/
  55 int
  56 getdata(void *window_mgr, const char *prompt, int fd, char *buf, const int size)
  57 {
  58     int     ret;
  59     int     i, j;
  60
  61     j = -1;
  62     for (i = 0; i < (size-1); i++)  {
  63         ret = read(fd, &buf[i], 1);
  64
  65         if (ret < 0)    {
  66             return(ret);
  67         }
  68
  69         if ((buf[i] == '\n') || (buf[i] == '\r'))   break;
  70         if (buf[i] == '\t') {
  71             buf[i] = ' ';
  72         }
  73         if ((buf[i] == '#') && (j < 0)) {
  74             j = i;
  75         }
  76     }
  77     buf[i] = 0;
  78     print_log("%s%s", prompt, buf);
  79
  80     /* Delete trailing spaces       */
  81     if (j >= 0) {
  82         for (; j > 0; j--)  {
  83             if (buf[j-1] != ' ')    break;
  84         }
  85         buf[j] = 0;
  86         i = j;
  87     }
  88
  89     /* Delete header spaces         */
  90     for (j = 0; buf[j]; j++)    {
  91         if (buf[j] != ' ')  break;
  92     }
  93     if (j > 0)  {
  94         strcpy( buf, &buf[j] );
  95         i -= j;
  96     }
  97     return(i);
  98 }
  99
 100 /*--------------------------------------------------------------------------*/
 101 /**
 102  * @brief   print_log: Weston log output
 103  *
 104  * @param[in]   fmt         printf format
 105  * @param[in]   ...         printf arguments
 106  * @return      None
 107  */
 108 /*--------------------------------------------------------------------------*/
 109 void
 110 print_log(const char *fmt, ...)
 111 {
 112     va_list     ap;
 113     char        log[128];
 114     struct timeval  NowTime;
 115     extern long timezone;
 116     static int  sTimeZone = (99*60*60);
 117
 118     va_start(ap, fmt);
 119     vsnprintf(log, sizeof(log)-2, fmt, ap);
 120     va_end(ap);
 121
 122     gettimeofday( &NowTime, (struct timezone *)0 );
 123     if( sTimeZone > (24*60*60) )    {
 124         tzset();
 125         sTimeZone = timezone;
 126     }
 127     NowTime.tv_sec -= sTimeZone;
 128     fprintf(stderr, "[%02d:%02d:%02d.%03d@%d] %s\n", (int)((NowTime.tv_sec/3600) % 24),
 129             (int)((NowTime.tv_sec/60) % 60), (int)(NowTime.tv_sec % 60),
 130             (int)NowTime.tv_usec/1000, getpid(), log);
 131 }
 132
 133 /*--------------------------------------------------------------------------*/
 134 /**
 135  * @brief   wayland_dispatch_nonblock: Read from wayland if receive data exist
 136  *
 137  * @param[in]   display     Wayland connection
 138  * @return      None
 139  */
 140 /*--------------------------------------------------------------------------*/
 141 void
 142 wayland_dispatch_nonblock(struct wl_display *display)
 143 {
 144     int     nread;
 145
 146     /* Check wayland input      */
 147     do  {
 148         /* Flush send data          */
 149         wl_display_flush(display);
 150
 151         nread = 0;
 152         if (ioctl(wl_display_get_fd(display), FIONREAD, &nread) < 0)    {
 153             nread = 0;
 154         }
 155         if (nread >= 8) {
 156             /* Read event from wayland  */
 157             wl_display_dispatch(display);
 158         }
 159     } while (nread > 0);
 160 }
 161
 162 /*--------------------------------------------------------------------------*/
 163 /**
 164  * @brief   sleep_with_wayland: Sleep and receive wayland event
 165  *
 166  * @param[in]   display     Wayland connection
 167  * @param[in]   msec        Sleep time (miri-sec)
 168  * @return      None
 169  */
 170 /*--------------------------------------------------------------------------*/
 171 void
 172 sleep_with_wayland(struct wl_display *display, int msec)
 173 {
 174     int     nread;
 175     int     fd;
 176
 177
 178     fd = wl_display_get_fd(display);
 179
 180     do  {
 181         /* Flush send data          */
 182         wl_display_flush(display);
 183
 184         /* Check wayland input      */
 185         nread = 0;
 186         if (ioctl(fd, FIONREAD, &nread) < 0)    {
 187             nread = 0;
 188         }
 189         if (nread >= 8) {
 190             /* Read event from wayland  */
 191             wl_display_dispatch(display);
 192         }
 193         msec -= 20;
 194         if (msec >= 0)   usleep(20*1000);
 195     } while (msec > 0);
 196 }
 197
 198 /*--------------------------------------------------------------------------*/
 199 /**
 200  * @brief   wait_with_wayland: Wait for end and receive wayland event
 201  *
 202  * @param[in]   display     Wayland connection
 203  * @param[in]   msec        Maximum wait time (miri-sec)
 204  * @param[in]   endflag     End flag address
 205  * @return      None
 206  */
 207 /*--------------------------------------------------------------------------*/
 208 void
 209 wait_with_wayland(struct wl_display *display, int msec, int *endflag)
 210 {
 211     int     nread;
 212     int     fd;
 213
 214     fd = wl_display_get_fd(display);
 215
 216     do  {
 217         /* Check wayland input      */
 218         while(1)    {
 219             /* Flush send data          */
 220             wl_display_flush(display);
 221
 222             nread = 0;
 223             if (ioctl(fd, FIONREAD, &nread) < 0)    {
 224                 nread = 0;
 225             }
 226             if (nread < 8)  break;
 227             /* Read event from wayland  */
 228             wl_display_dispatch(display);
 229         }
 230         msec -= 20;
 231         if (msec >= 0)   usleep(20*1000);
 232     } while ((*endflag == 0) && (msec > 0));
 233 }
 234
 235 /*--------------------------------------------------------------------------*/
 236 /**
 237  * @brief   sec_str_2_value: Convert seconds string to value
 238  *
 239  * @param[in]   ssec        Time ("sec.msec")
 240  * @return      miri-second
 241  */
 242 /*--------------------------------------------------------------------------*/
 243 int
 244 sec_str_2_value(const char *ssec)
 245 {
 246     int     sec;
 247     int     msec;
 248     int     n;
 249     char    *errp = NULL;
 250
 251     sec = strtol(ssec, &errp, 0) * 1000;
 252     if ((errp != NULL) && (*errp == '.'))   {
 253         msec = 0;
 254         n = 0;
 255         for (errp++; *errp; errp++) {
 256             if ((*errp < '0') || (*errp > '9')) break;
 257             msec = msec * 10 + *errp - '0';
 258             n++;
 259             if (n >= 3) break;
 260         }
 261         if (n == 1)     msec *= 100;
 262         if (n == 2)     msec *= 10;
 263         sec += msec;
 264     }
 265     return(sec);
 266 }
 267
 268 /*--------------------------------------------------------------------------*/
 269 /**
 270  * @brief   opengl_init: Initialize OpenGL ESv2/EGL
 271  *
 272  * @param[in]   display     Wayland connection
 273  * @param[out]  rconf       EGL configuration
 274  * @param[out]  rctx        EGL context
 275  * @return      EGL display
 276  * @retval      != NULL     EGL display
 277  * @retval      == NULL     OpenGL/EGL initialize error
 278  */
 279 /*--------------------------------------------------------------------------*/
 280 EGLDisplay
 281 opengl_init(struct wl_display *display, EGLConfig *rconf, EGLContext *rctx)
 282 {
 283     EGLDisplay  dpy;                    /* EGL dsplay id                    */
 284     EGLint      major, minor;
 285     EGLint      num_configs;
 286     EGLConfig   conf = 0;
 287     EGLContext  ctx;
 288
 289     static const EGLint config_attribs[] = {
 290         EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
 291         EGL_RED_SIZE, 1,
 292         EGL_GREEN_SIZE, 1,
 293         EGL_BLUE_SIZE, 1,
 294         EGL_ALPHA_SIZE, 1,
 295         EGL_DEPTH_SIZE, 1,
 296         EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
 297         EGL_NONE
 298     };
 299     static const EGLint context_attribs[] = {
 300         EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE
 301     };
 302
 303     dpy = eglGetDisplay((EGLNativeDisplayType)display);
 304     if (! dpy)  {
 305         fprintf(stderr, "eglGetDisplay Error\n");
 306         return NULL;
 307     }
 308
 309     if (eglInitialize(dpy, &major, &minor) == EGL_FALSE)    {
 310         fprintf(stderr, "eglInitialize Error\n");
 311         return NULL;
 312     }
 313
 314     if (eglBindAPI(EGL_OPENGL_ES_API) == EGL_FALSE) {
 315         fprintf(stderr, "eglBindAPI Error\n");
 316         return NULL;
 317     }
 318
 319     if (eglChooseConfig(dpy, config_attribs, &conf, 1, &num_configs) == EGL_FALSE)  {
 320         fprintf(stderr, "eglChooseConfig Error\n");
 321         return NULL;
 322     }
 323
 324     ctx = eglCreateContext(dpy, conf, EGL_NO_CONTEXT, context_attribs);
 325     if (! ctx)  {
 326         fprintf(stderr, "eglCreateContext Error\n");
 327         return NULL;
 328     }
 329     *rconf = conf;
 330     *rctx = ctx;
 331
 332     wayland_dispatch_nonblock(display);
 333
 334     return(dpy);
 335 }
 336
 337 /*--------------------------------------------------------------------------*/
 338 /**
 339  * @brief   opengl_create_window: Create OpenGL/EGL window
 340  *
 341  * @param[in]   display     Wayland connection
 342  * @param[in]   surface     Wayland surface
 343  * @param[in]   dpy         EGL display
 344  * @param[in]   conf        EGL configuration
 345  * @param[in]   ctx         EGL context
 346  * @param[in]   width       Widown width
 347  * @param[in]   height      Window height
 348  * @param[in]   color       Initiale color(A<<24|R<<16|G<<8|B)
 349  * @return      EGL surface
 350  * @retval      != NULL     EGL surface
 351  * @retval      == NULL     Create window error
 352  */
 353 /*--------------------------------------------------------------------------*/
 354 EGLSurface
 355 opengl_create_window(struct wl_display *display, struct wl_surface *surface,
 356                      EGLDisplay dpy, EGLConfig conf, EGLContext ctx,
 357                      const int width, const int height, const int color)
 358 {
 359     struct wl_egl_window    *egl_window;
 360     EGLSurface              egl_surface;
 361
 362     static const EGLint surface_attribs[] = {
 363         EGL_ALPHA_FORMAT, EGL_ALPHA_FORMAT_PRE, EGL_NONE
 364     };
 365
 366     egl_window = wl_egl_window_create(surface, width, height);
 367     egl_surface = eglCreateWindowSurface(dpy, conf, (EGLNativeWindowType)egl_window,
 368                                          surface_attribs);
 369     eglMakeCurrent(dpy, egl_surface, egl_surface, ctx);
 370     glViewport(0, 0, width, height);
 371
 372     wayland_dispatch_nonblock(display);
 373
 374     opengl_clear_window(color);
 375
 376     opengl_swap_buffer(display, dpy, egl_surface);
 377
 378     return(egl_surface);
 379 }
 380
 381 /*--------------------------------------------------------------------------*/
 382 /**
 383  * @brief   opengl_clear_window: OpenGL window clear
 384  *
 385  * @param[in]   color       Initiale color(A<<24|R<<16|G<<8|B)
 386  * @return      None
 387  */
 388 /*--------------------------------------------------------------------------*/
 389 void
 390 opengl_clear_window(const unsigned int color)
 391 {
 392     double                  r, g, b, a;
 393
 394     r = (double)((color>>16) & 0x0ff);
 395     r = r / 256.0;
 396     g = (double)((color>>8) & 0x0ff);
 397     g = g / 256.0;
 398     b = (double)(color & 0x0ff);
 399     b = b / 256.0;
 400     a = (double)((color>>24) & 0x0ff);
 401     a = (a + 1.0) / 256.0;
 402
 403     glClearColor(r, g, b, a);
 404     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT| GL_STENCIL_BUFFER_BIT);
 405 }
 406
 407 /*--------------------------------------------------------------------------*/
 408 /**
 409  * @brief   opengl_create_window: Create OpenGL/EGL window
 410  *
 411  * @param[in]   display     Wayland connection
 412  * @param[in]   dpy         EGL display
 413  * @param[in]   egl_surface EGL surface
 414  * @return      None
 415  */
 416 /*--------------------------------------------------------------------------*/
 417 void
 418 opengl_swap_buffer(struct wl_display *display, EGLDisplay dpy, EGLSurface egl_surface)
 419 {
 420     eglSwapBuffers(dpy, egl_surface);
 421
 422     wayland_dispatch_nonblock(display);
 423 }
 424