xrdp-proprietary/xorg/tests/xdemo/xdemo.c

/**
 * xrdp: A Remote Desktop Protocol server.
 *
 * Copyright (C) Laxmikant Rashinkar 2012
 *
 * 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 <unistd.h>
#include <fcntl.h>
#include <time.h>
#include <stdint.h>
#include <string.h>
#include <sys/types.h>
#include <sys/time.h>
#include <signal.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include "common.h"

// LK_TODO
// http://tronche.com/gui/x/xlib/GC/convenience-functions/fill-tile-and-stipple.html
// fill stipple

// drawfonts: XDrawString, XDrawImageString XDrawText XLoadFont XTextExtents
// http://www.ac3.edu.au/SGI_Developer/books/XLib_PG/sgi_html/apa.html
// http://www.ac3.edu.au/SGI_Developer/books/XLib_PG/sgi_html/index.html

// use jpg lib to convert bmp to jpg and vice versa

#define MAX_COLORS          5
#define SCROLL_JUMP         1   // scroll in increments of g_winHeight
#define SCROLL_SMOOTH1      2   // scroll using XPutImage + XCopyArea
#define SCROLL_SMOOTH2      3   // scroll using XPutImage only
#define SCROLL_SMOOTH3      4   // scroll using XPutImage only
#define SCROLL_SMOOTH4      5   // scroll using XPutImage only

int parse_bmp(char *filename, struct pic_info *);
int drawBMP(char *filename, int scroll_type);
int signal_tcp_proxy(char *proxy_app);

// globals
Display     *g_disp;
Window      g_win;
XColor      g_colors[MAX_COLORS];
GC          g_gc;
int         g_winWidth;
int         g_winHeight;
int         g_delay_dur;

void start_timer(struct timeval *tv)
{
    gettimeofday(tv, NULL);
}


uint32_t time_elapsed_ms(struct timeval tv)
{
    struct timeval  tv_now;
    uint32_t        dur;

    gettimeofday(&tv_now, NULL);
    dur = ((tv_now.tv_sec - tv.tv_sec) * 1000) + ((tv_now.tv_usec - tv.tv_usec) / 1000);
    return dur;
}


uint32_t time_elapsed_us(struct timeval tv)
{
    struct timeval  tv_now;
    uint32_t        dur;

    gettimeofday(&tv_now, NULL);
    dur = ((tv_now.tv_sec - tv.tv_sec) * 1000000) + (tv_now.tv_usec - tv.tv_usec);
    return dur;
}

int drawLines(int count)
{
    int x1;
    int y1;
    int x2;
    int y2;
    int i;
    int index;

    if (count <= 0)
    {
        return 0;                  // nothing to do
    }

    srandom(time(NULL));
    XClearArea(g_disp, g_win, 0, 0, g_winWidth, g_winHeight, 0);

    for (i = 0, index = 0; i < count; i++)
    {
        x1 = random() % g_winWidth;
        y1 = random() % g_winHeight;
        x2 = random() % g_winWidth;
        y2 = random() % g_winHeight;
        XSetForeground(g_disp, g_gc, g_colors[index++].pixel);

        if (index == MAX_COLORS)
        {
            index = 0;
        }

        // from-to
        XDrawLine(g_disp, g_win, g_gc, x1, y1, x2, y2);
        XFlush(g_disp);
        usleep(g_delay_dur);
    }

    return 0;
}

// LK_TODO support user defined w and h

int drawRectangles(int count)
{
    int x1;
    int y1;
    int w;
    int h;
    int i;
    int index;

    if (count <= 0)
    {
        return 0;  // nothing to do
    }

    srandom(time(NULL));
    XClearArea(g_disp, g_win, 0, 0, g_winWidth, g_winHeight, 0);

    for (i = 0, index = 0; i < count; i++)
    {
        x1 = random() % g_winWidth;
        y1 = random() % g_winHeight;
        w = 160;
        h = 140;
        XSetForeground(g_disp, g_gc, g_colors[index++].pixel);

        if (index == MAX_COLORS)
        {
            index = 0;
        }

        //XDrawRectangle(g_disp, g_win, g_gc, x1, y1, w, h);
        XFillRectangle(g_disp, g_win, g_gc, x1, y1, w, h);
        XFlush(g_disp);
        usleep(g_delay_dur);
    }

    return 0;
}

int drawFont(int count, char *msg)
{
    int  x1;
    int  y1;
    int  i;
    int  index;

#ifdef CHANGE_FONT_SIZE
    int  w;
    int  h;
    int  actual_count;
    char **font_list;
#endif

    if (count <= 0)
    {
        return 0; // nothing to do
    }

    srandom(time(NULL));
    XClearArea(g_disp, g_win, 0, 0, g_winWidth, g_winHeight, 0);

#ifdef CHANGE_FONT_SIZE
    font_list = XListFonts(g_disp, "−*−courier−*−*−*−*−0−0−*−*−*−0−*−*", 2000, &actual_count);

    if (!font_list)
    {
        printf("actual_count=%d\n", actual_count);

        for (i = 0; i < actual_count; i++)
        {
            printf("%s\n", font_list[i]);
        }

        XFreeFontNames(font_list);
    }
    else
    {
        printf("XListFonts() returned NULL\n");
    }

#endif

    srandom(time(NULL));

    for (i = 0, index = 0; i < count; i++)
    {
        x1 = random() % g_winWidth;
        y1 = random() % g_winHeight;
        XSetForeground(g_disp, g_gc, g_colors[index++].pixel);

        if (index == MAX_COLORS)
        {
            index = 0;
        }

        XDrawString(g_disp, g_win, g_gc, x1, y1, msg, strlen(msg));
        XFlush(g_disp);
        usleep(g_delay_dur);
    }

    return 0; // nothing to do
}

static void
drawoffscreen(void)
{
    int depth;
    Pixmap pixmap1;
    Pixmap pixmap2;

    printf("draw off screen, should see green rect\n");
    depth = DefaultDepth(g_disp, DefaultScreen(g_disp));

    /* blue */
    pixmap1 = XCreatePixmap(g_disp, g_win, 64, 64, depth);
    XSetForeground(g_disp, g_gc, 0x000000ff);
    XFillRectangle(g_disp, pixmap1, g_gc, 0, 0, 64, 64);

    /* green */
    pixmap2 = XCreatePixmap(g_disp, g_win, 64, 64, depth);
    XSetForeground(g_disp, g_gc, 0x0000ff00);
    XFillRectangle(g_disp, pixmap2, g_gc, 0, 0, 64, 64);

    /* copy green to blue */
    XCopyArea(g_disp, pixmap2, pixmap1, g_gc, 0, 0, 64, 64, 0, 0);

    /* put on screen */
    XCopyArea(g_disp, pixmap1, g_win, g_gc, 0, 0, 64, 64, 128, 128);

    XFreePixmap(g_disp, pixmap1);
    XFreePixmap(g_disp, pixmap2);
}

/**
 * display a usage message
 */
static void
usage(void)
{
    printf("usage: xdemo [-l] [-r] [-s] [-f <string>] [-i <image file>] [-g <WxH>] [-c <count>] [-o <scroll type>] [-d <delay>] -z\n");
    printf("         -l                        draw lines\n");
    printf("         -r                        draw fill rectangles\n");
    printf("         -s                        draw stipple rectangles\n");
    printf("         -f <string>               draw string using fonts\n");
    printf("         -i <image file>           draw image\n");
    printf("         -g <WxH>                  geometry, default is 640x480\n");
    printf("         -c <count>                iteration count, default is 5000\n");
    printf("         -d <delay>                loop delay in micro seconds, default 1000\n");
    printf("         -o <jump|smooth1|smooth2| define scrolling method\n");
    printf("             smooth3|smooth4>\n");
    printf("         -z <proxy_app>            zero proxy counters for specified application\n");
    printf("         -j                        offscreen to offscreen test\n\n");
}

int
main(int argc, char **argv)
{
    XEvent          evt;
    Colormap        colormap;
    struct timeval  tv;
    int             screenNumber;
    long            eventMask;
    unsigned long   white;
    unsigned long   black;
    Status          rc;
    int             iters;
    int             opt;
    int             draw_lines;
    int             draw_rects;
    int             draw_stipples;
    int             draw_fonts;
    int             draw_image;
    int             draw_offscreen;
    int             zero_counters;
    int             scroll_type;
    char            image_file[256];
    char            proxy_app[256];
    char            msg[4096];

    // set some defaults
    g_winWidth = 640;
    g_winHeight = 480;
    iters = 5000;
    draw_lines = 1;
    draw_rects = 1;
    draw_stipples = 1;
    draw_fonts = 1;
    draw_image = 1;
    draw_offscreen = 1;
    g_delay_dur = 1000;
    scroll_type = SCROLL_SMOOTH1;
    zero_counters = 0;
    strcpy(image_file, "yosemite.bmp");
    strcpy(msg, "To be or not to be!");

    // process cmd line args
    opterr = 0;

    while ((opt = getopt(argc, argv, "lrsjg:c:f:i:d:o:z:")) != -1)
    {
        switch (opt)
        {

            case 'j':
                draw_lines = 0;
                draw_rects = 0;
                draw_stipples = 0;
                draw_fonts = 0;
                draw_image = 0;
                draw_offscreen = 1;
                break;

            case 'g':

                if (sscanf(optarg, "%dx%d", &g_winWidth, &g_winHeight) != 2)
                {
                    fprintf(stderr, "\nerror: invalid geometry specified\n\n");
                    usage();
                    return -1;
                }

                break;

            case 'c':

                if (sscanf(optarg, "%d", &iters) != 1)
                {
                    fprintf(stderr, "\nerror: invalid count specified\n\n");
                    usage();
                    return -1;
                }

                break;

            case 'l':
                draw_lines = 1;
                draw_rects = 0;
                draw_stipples = 0;
                draw_fonts = 0;
                draw_image = 0;
                draw_offscreen = 0;
                break;

            case 'r':
                draw_rects = 1;
                draw_lines = 0;
                draw_stipples = 0;
                draw_fonts = 0;
                draw_image = 0;
                draw_offscreen = 0;
                break;

            case 's':
                draw_stipples = 1;
                draw_lines = 0;
                draw_rects = 0;
                draw_fonts = 0;
                draw_image = 0;
                draw_offscreen = 0;
                break;

            case 'f':

                if (strlen(optarg) <= 0)
                {
                    fprintf(stderr, "\nerror: -f option requires an argument\n\n");
                    usage();
                    return -1;
                }

                draw_fonts = 1;
                strncpy(msg, optarg, 4096);
                draw_lines = 0;
                draw_rects = 0;
                draw_stipples = 0;
                draw_image = 0;
                draw_offscreen = 0;
                break;

            case 'i':

                if (strlen(optarg) <= 0)
                {
                    fprintf(stderr, "\nerror: -i option requires an argument\n\n");
                    usage();
                    return -1;
                }

                draw_image = 1;
                strncpy(image_file, optarg, 255);
                draw_lines = 0;
                draw_rects = 0;
                draw_stipples = 0;
                draw_fonts = 0;
                draw_offscreen = 0;
                break;

            case 'h':
                usage();
                return 0;
                break;

            case 'v':
                printf("xdemo Ver 1.0\n");
                return 0;
                break;

            case 'd':

                if (sscanf(optarg, "%d", &g_delay_dur) != 1)
                {
                    fprintf(stderr, "\nerror: -d option requires an argument\n\n");
                    usage();
                    return -1;
                }

                break;

            case 'z':

                if (strlen(optarg) <= 0)
                {
                    fprintf(stderr, "\nerror: invalid proxy application specified\n\n");
                    usage();
                    return -1;
                }

                strcpy(proxy_app, optarg);
                printf("##### LK_TODO: proxy_app=%s\n", proxy_app);
                zero_counters = 1;
                break;

            case 'o':

                if (strcmp(optarg, "jump") == 0)
                {
                    scroll_type = SCROLL_JUMP;
                }
                else if (strcmp(optarg, "smooth1") == 0)
                {
                    scroll_type = SCROLL_SMOOTH1;
                }
                else if (strcmp(optarg, "smooth2") == 0)
                {
                    scroll_type = SCROLL_SMOOTH2;
                }
                else if (strcmp(optarg, "smooth3") == 0)
                {
                    scroll_type = SCROLL_SMOOTH3;
                }
                else if (strcmp(optarg, "smooth4") == 0)
                {
                    scroll_type = SCROLL_SMOOTH4;
                }
                else
                {
                    fprintf(stderr, "\ninvalid scroll type specified\n\n");
                    usage();
                    return -1;
                }

                break;

            default:
                usage();
                return -1;
        }
    }

    // must have at least one operation
    if ((!draw_lines) && (!draw_rects) && (!draw_stipples) &&
            (!draw_fonts) && (!draw_image) && (!draw_offscreen))
    {
        usage();
        return -1;
    }

    g_disp = XOpenDisplay(NULL);

    if (!g_disp)
    {
        dprint("error opening X display\n");
        exit(-1);
    }

    screenNumber = DefaultScreen(g_disp);
    white = WhitePixel(g_disp, screenNumber);
    black = BlackPixel(g_disp, screenNumber);

    g_win = XCreateSimpleWindow(g_disp,
                                DefaultRootWindow(g_disp),
                                50, 50,                  // origin
                                g_winWidth, g_winHeight, // size
                                0, black,                // border
                                white );                 // backgd

    XMapWindow(g_disp, g_win);
    //eventMask = StructureNotifyMask | MapNotify | VisibilityChangeMask;
    eventMask = StructureNotifyMask | VisibilityChangeMask;
    XSelectInput(g_disp, g_win, eventMask);

    g_gc = XCreateGC(g_disp, g_win,
                     0,                       // mask of values
                     NULL );                  // array of values
#if 0

    do
    {
        dprint("about to call XNextEvent(...)\n");
        XNextEvent(g_disp, &evt);// calls XFlush
        dprint("returned from XNextEvent(...)\n");
    }

    //while(evt.type != MapNotify);
    while (evt.type != VisibilityNotify)
    {
        ;
    }

#endif

    // get access to the screen's color map
    colormap = DefaultColormap(g_disp, screenNumber);

    // alloc red color
    rc = XAllocNamedColor(g_disp, colormap, "red", &g_colors[0], &g_colors[0]);

    if (rc == 0)
    {
        printf("XAllocNamedColor - failed to allocated 'red' color.\n");
        exit(1);
    }

    rc = XAllocNamedColor(g_disp, colormap, "green", &g_colors[1], &g_colors[1]);

    if (rc == 0)
    {
        printf("XAllocNamedColor - failed to allocated 'green' color.\n");
        exit(1);
    }

    rc = XAllocNamedColor(g_disp, colormap, "blue", &g_colors[2], &g_colors[2]);

    if (rc == 0)
    {
        printf("XAllocNamedColor - failed to allocated 'blue' color.\n");
        exit(1);
    }

    rc = XAllocNamedColor(g_disp, colormap, "yellow", &g_colors[3], &g_colors[3]);

    if (rc == 0)
    {
        printf("XAllocNamedColor - failed to allocated 'yellow' color.\n");
        exit(1);
    }

    rc = XAllocNamedColor(g_disp, colormap, "orange", &g_colors[4], &g_colors[4]);

    if (rc == 0)
    {
        printf("XAllocNamedColor - failed to allocated 'orange' color.\n");
        exit(1);
    }

    if (zero_counters)
    {
        signal_tcp_proxy(proxy_app);
    }

    if (draw_lines)
    {
        start_timer(&tv);
        drawLines(iters);
        printf("drew %d lines in %d ms\n", iters, time_elapsed_ms(tv));
    }

    if (draw_rects)
    {
        start_timer(&tv);
        drawRectangles(iters);
        printf("drew %d rects in %d ms\n", iters, time_elapsed_ms(tv));
    }

    if (draw_stipples)
    {
        start_timer(&tv);
        // LK_TODO
    }

    if (draw_fonts)
    {
        start_timer(&tv);
        drawFont(iters, msg);
        printf("drew %d strings in %d ms\n", iters, time_elapsed_ms(tv));
    }

    if (draw_image)
    {
        start_timer(&tv);
        drawBMP(image_file, scroll_type);
        printf("drew BMP in %d ms\n", time_elapsed_ms(tv));
    }

    if (draw_offscreen)
    {
    }

    if (zero_counters)
    {
        signal_tcp_proxy(proxy_app);
    }

    eventMask = ButtonPressMask | ButtonReleaseMask | KeyPressMask;

    XSelectInput(g_disp, g_win, eventMask);

    do
    {
        XNextEvent(g_disp, &evt); // calls XFlush()

        if (evt.type == KeyPress)
        {
            if (draw_offscreen)
            {
                drawoffscreen();
            }
        }

    }
    while (evt.type != ButtonRelease);

    XDestroyWindow(g_disp, g_win);
    XCloseDisplay(g_disp);

    return 0;
}

int drawBMP(char *filename, int scroll_type)
{
    struct   pic_info pic_info;
    XImage   *image;
    Visual   *visual;
    Pixmap   pixmap;
    int      depth;
    int      i;
    int      j;

    if (parse_bmp(filename, &pic_info) < 0)
    {
        exit(-1);
    }

    XClearArea(g_disp, g_win, 0, 0, g_winWidth, g_winHeight, 0);

    depth = DefaultDepth(g_disp, DefaultScreen(g_disp));
    visual = DefaultVisual(g_disp, DefaultScreen(g_disp));

    // create empty pixmap
    pixmap = XCreatePixmap(g_disp, g_win, pic_info.width, pic_info.height, depth);

    // create an image from pixel data
    image = XCreateImage(g_disp, visual, depth, ZPixmap, 0, pic_info.pixel_data,
                         pic_info.width, pic_info.height, 32, 0);

    if (pic_info.height <= g_winHeight)
    {
        // image is too small to scroll
        XFlush(g_disp);
        XPutImage(g_disp, g_win, g_gc, image, 0, 0, 0, 0, pic_info.width, pic_info.height);
        XFlush(g_disp);
        return 0;
    }

    // copy image to pixelmap
    XPutImage(g_disp, pixmap, g_gc, image, 0, 0, 0, 0, pic_info.width, pic_info.height);

    if (scroll_type == SCROLL_JUMP)
    {

        if (pic_info.height <= g_winHeight)
        {
            // image too small - no scrolling required
            XFlush(g_disp);
            XCopyArea(g_disp,           // connection to X server
                      pixmap,           // source drawable
                      g_win,            // dest drawable
                      g_gc,             // graphics context
                      0, 0,             // source x,y
                      pic_info.width,   // width
                      pic_info.height,  // height
                      0, 0);            // dest x,y
            XFlush(g_disp);
            return 0;
        }

        j = pic_info.height / g_winHeight;

        if (pic_info.height % g_winHeight != 0)
        {
            // need to include the last part of the image
            j++;
        }

        XFlush(g_disp);

        for (i = 0; i < j; i++)
        {
            XCopyArea(g_disp,               // connection to X server
                      pixmap,               // source drawable
                      g_win,                // dest drawable
                      g_gc,                 // graphics context
                      0, i * g_winHeight,   // source x,y
                      pic_info.width,       // width
                      pic_info.height,      // height
                      0, 0);                // dest x,y
            XFlush(g_disp);
            sleep(3);
        }
    }

    /*
    ** smooth scroll the image
    */

    // number of lines to be scrolled
    j = pic_info.height - g_winHeight;

    if (scroll_type == SCROLL_SMOOTH1)
    {
        printf("running SCROLL_SMOOTH1\n");
        XFlush(g_disp);
        XPutImage(g_disp, g_win, g_gc, image, 0, 0, 0, 0, pic_info.width, pic_info.height);
        XFlush(g_disp);
        usleep(10000);

        for (i = 0; i < j; i++)
        {
            XCopyArea(g_disp, g_win, g_win, g_gc, 0, 1, g_winWidth, g_winHeight - 1, 0, 0);
            XPutImage(g_disp, g_win, g_gc, image, 0, g_winHeight + i, 0, g_winHeight - 1 , pic_info.width, 1);
            XFlush(g_disp);
            usleep(10000);
        }

        return 0;
    }

    if (scroll_type == SCROLL_SMOOTH2)
    {
        printf("running SCROLL_SMOOTH2\n");
        XFlush(g_disp);

        for (i = 0; i < j; i++)
        {
            XPutImage(g_disp, g_win, g_gc, image, 0, i, 0, 0, pic_info.width, pic_info.height - i);
            XFlush(g_disp);
            usleep(10000);
        }
    }

    if (scroll_type == SCROLL_SMOOTH3)
    {
        printf("running SCROLL_SMOOTH3\n");
        XFlush(g_disp);
        XCopyArea(g_disp, pixmap, g_win, g_gc, 0, 0, pic_info.width, pic_info.height, 0, 0);
        XFlush(g_disp);
        usleep(10000);

        for (i = 0; i < j; i++)
        {
            XCopyArea(g_disp, g_win, g_win, g_gc, 0, 1, g_winWidth, g_winHeight - 1, 0, 0);
            XCopyArea(g_disp, pixmap, g_win, g_gc, 0, g_winHeight + i, pic_info.width, 1, 0, g_winHeight - 1);
            XFlush(g_disp);
            usleep(10000);
        }

        return 0;
    }

    if (scroll_type == SCROLL_SMOOTH4)
    {
        printf("running SCROLL_SMOOTH4\n");
        XFlush(g_disp);

        for (i = 0; i < j; i++)
        {
            XCopyArea(g_disp, pixmap, g_win, g_gc, 0, i, pic_info.width, pic_info.height - i, 0, 0);
            XFlush(g_disp);
            usleep(10000);
        }
    }

    return 0;
}

int process_bmp_event(void)
{
    XEvent ev;
    long   event_mask;

    event_mask = ExposureMask | ButtonPressMask | ButtonReleaseMask | StructureNotifyMask;
    XSelectInput(g_disp, g_win, event_mask);
    XNextEvent(g_disp, &ev);

    switch (ev.type)
    {
        case Expose:
            printf("got expose event\n");
            break;

        default:
            printf("did not get expose event\n");
            break;
    }

    return 0;
}

/**
 * send a SIGUSR1 to process tcp_proxy, causing it to clear counters
 *
 * @return 0 on success, -1 on failure
 */

int signal_tcp_proxy(char *proc_name)
{
    FILE *fp;
    char *cptr;
    char buf[2048];
    int  pids[10];
    int  status = 0;
    int  num_procs;
    int  i;

    sprintf(buf, "pidof %s", proc_name);

    if ((fp = popen(buf, "r")) == NULL )
    {
        printf("xdemo: popen() failed\n");
        return -1;
    }

    cptr = fgets(buf, 2047, fp);

    if (cptr == NULL)
    {
        pclose(fp);
        return -1;
    }

    num_procs = sscanf(buf, "%d %d %d %d %d %d %d %d %d %d",
                       &pids[0], &pids[1], &pids[2], &pids[3], &pids[4],
                       &pids[5], &pids[6], &pids[7], &pids[8], &pids[9]);

    if (num_procs > 0)
    {
        for (i = 0; i < num_procs; i++)
        {
            kill(pids[i], SIGUSR1);
            printf("sent SIGUSR1 to process %d\n", pids[i]);
        }
    }

    pclose(fp);
    return status;
}