path: root/main.c

#include <X11/Xlib.h>
#include <X11/extensions/Xrender.h>

#include <sys/time.h>
#include <time.h>
#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>

#include "utils.h"
#include "surface.h"
#include "testscenarios.h"
#include "config.h"

int               win_w = 538;
int               win_h = 451;
Display          *disp = NULL;
Window            win;
int               test_type = AllTests;
Bool              useARGBWindow;
double            test_time = 2.0;

RenderOp all_render_ops[] = {
    {"Clear",               PictOpClear,               1},
    {"Src",                 PictOpSrc,                 1},
    {"Dst",                 PictOpDst,                 1},
    {"Over",                PictOpOver,                1},
    {"OverReverse",         PictOpOverReverse,         1},
    {"In",                  PictOpIn,                  1},
    {"InReverse",           PictOpInReverse,           1},
    {"Out",                 PictOpOut,                 1},
    {"OutReverse",          PictOpOutReverse,          1},
    {"Atop",                PictOpAtop,                1},
    {"AtopReverse",         PictOpAtopReverse,         1},
    {"Xor",                 PictOpXor,                 1},
    {"Add",                 PictOpAdd,                 1},
    {"Saturate",            PictOpSaturate,            1},
    {"DisjointClear",       PictOpDisjointClear,       1},
    {"DisjointSrc",         PictOpDisjointSrc,         0},
    {"DisjointDst",         PictOpDisjointDst,         0},
    {"DisjointOver",        PictOpDisjointOver,        0},
    {"DisjointOverReverse", PictOpDisjointOverReverse, 0},
    {"DisjointIn",          PictOpDisjointIn,          0},
    {"DisjointInReverse",   PictOpDisjointInReverse,   0},
    {"DisjointOut",         PictOpDisjointOut,         0},
    {"DisjointOutReverse",  PictOpDisjointOutReverse,  0},
    {"DisjointAtop",        PictOpDisjointAtop,        0},
    {"DisjointAtopReverse", PictOpDisjointAtopReverse, 0},
    {"DisjointXor",         PictOpDisjointXor,         0},
    {"ConjointClear",       PictOpConjointClear,       0},
    {"ConjointSrc",         PictOpConjointSrc,         0},
    {"ConjointDst",         PictOpConjointDst,         0},
    {"ConjointOver",        PictOpConjointOver,        0},
    {"ConjointOverReverse", PictOpConjointOverReverse, 0},
    {"ConjointIn",          PictOpConjointIn,          0},
    {"ConjointInReverse",   PictOpConjointInReverse,   0},
    {"ConjointOut",         PictOpConjointOut,         0},
    {"ConjointOutReverse",  PictOpConjointOutReverse,  0},
    {"ConjointAtop",        PictOpConjointAtop,        0},
    {"ConjointAtopReverse", PictOpConjointAtopReverse, 0},
    {"ConjointXor",         PictOpConjointXor,         0},
    {NULL,                  0,                         0}
};


void
test_oper(int op, XRenderSurf *src, XRenderSurf *mask, XRenderSurf *dst)
{
    int x, y;

    x = rand() % (dst->w - (src->w/2));
    y = rand() % (dst->h - (src->h/2));
    xrender_surf_blend(disp, op, src, mask, dst,
                       0, 0, 0, 0, x, y, src->w, src->h);
}

static Picture createBackgroundPicture()
{
    unsigned int w, h;
    char *data;
    Picture back;
    XRenderSurf *surf;

    readPng("images/fdo-translucent.png", &data, &w, &h);
    surf = xrender_surf_new(disp, win, PictStandardARGB32, w, h, False);
    xrender_surf_populate(disp, surf, w, h, data);
    XRenderPictureAttributes pa;
    pa.repeat = 1;
    XRenderChangePicture(disp, surf->pic, CPRepeat, &pa);

    back = surf->pic;

    if (surf->allocated)
        XFreePixmap(disp, surf->draw);
    free(surf);

    return back;
}

void
main_loop(void)
{
    RenderOp *current_op;
    Picture backgroundPict;
    int xrenderMajor, xrenderMinor;
    int j = 0;
    int numberOfScenarios = 0;

    XRenderQueryVersion(disp, &xrenderMajor, &xrenderMinor);

    srand(time(0));

    printf("X Server from: %s, Release: %d\n", ServerVendor(disp), VendorRelease(disp));
    printf("\tXrender version: %d.%d\n", xrenderMajor, xrenderMinor);
    printf("---------------------------------------------\n");


    backgroundPict = createBackgroundPicture();

    TestScenario *scenarios = create_test_scenarios(disp, win, win_w, win_h, &numberOfScenarios);

    XRenderComposite(disp, PictOpSrc, backgroundPict, None,
                     scenarios[0].dst->pic, 0, 0, 0, 0, 0, 0, win_w, win_h);
    XFlush(disp);

    for (current_op = &all_render_ops[0]; current_op->name; current_op++)
    {
        if (current_op->disabled)
            continue;

        printf("Test: %s\n", current_op->name);

        for (j = 0; j < numberOfScenarios; ++j) {
            TestScenario *currentTest = &(scenarios[j]);

            XRenderComposite(disp, PictOpSrc, backgroundPict, None,
                             currentTest->dst->pic, 0, 0, 0, 0, 0, 0, win_w,
                             win_h);

            if (test_type != AllTests) {
                if (!(currentTest->types & test_type))
                    continue;
            }

            time_test(currentTest->name, test_oper, current_op,
                      currentTest->src, currentTest->mask, currentTest->dst);

            XSync(disp, False);
        }
    }
}


void
display_help()
{
    printf("./xrenderbenchmark \n");
    printf("\t -help\t\tdisplays help\n");
    printf("\t -argb\t\tuses a 32-bit ARGB window\n");
    printf("\t -ops ops\tconfigures which ops to test\n");
    printf("\t -tests type\truns only specified tests\n");
    printf("\t\ttype can be: plain, alpha, mask, transformation, filter,\n");
    printf("\t\tand convolution\n");
    printf("\t -time sec\tcontrol the test time in seconds (default: 2 sec)\n");
    printf("\t \n");
}

void
process_args(int argc, char **argv)
{
    int i;
    for (i = 1; i < argc; ++i) {
        char *arg = argv[i];

        if (!strcmp("-help", arg)) {
            display_help();
            exit(1);
        } else if (!strcmp("-argb", arg)) {
            useARGBWindow = True;
        } else if (!strcmp("-ops", arg)) {
            char *opname, *nextname;
            RenderOp *op;

            ++i;
            if (i == argc) {
                fprintf(stderr, "Error: -ops expected a comma-separated list of ops\n");
                exit(1);
            }

            nextname = argv[i];

            for (op = &all_render_ops[0]; op->name; op++)
                op->disabled = True;

            while ((opname = strsep(&nextname, ",")) != NULL) {
                for (op = &all_render_ops[0]; op->name; op++) {
                    if (strcasecmp(op->name, opname) != 0)
                        continue;
                    op->disabled = False;
                    break;
                }
                if (!op->name) {
                    display_help();
                    exit(1);
                }
            }
        } else if (!strcmp("-tests", arg)) {
            ++i;
            if (i == argc) {
                fprintf(stderr, "Error: Must specify a test type with -tests option\n");
                exit(1);
            }
            arg = argv[i];
            if (!strcmp("plain", arg)) {
                test_type = PlainTest;
            } else if (!strcmp("alpha", arg)) {
                test_type = AlphaTest;
            } else if (!strcmp("mask", arg)) {
                test_type = MaskTest;
            } else if (!strcmp("transformation", arg)) {
                test_type = TransformationTest;
            } else if (!strcmp("filter", arg)) {
                test_type = FilterTest;
            } else if (!strcmp("convolution", arg)) {
                test_type = ConvolutionTest;
            } else {
                fprintf(stderr, "Unrecognized test type: '%s'\n", arg);
            }
        } else if (!strcmp("-time", arg)) {
            ++i;
            if (i == argc) {
                fprintf(stderr, "Error: Must specify a time in seconds with the -time option\n");
                exit(1);
            }
            arg = argv[i];
            test_time = strtod(argv[i], &arg);
            if (arg == argv[i] || *arg != '\0') {
                fprintf(stderr, "'%s': unrecognized number\n", argv[i]);
                exit(1);
            }
        } else {
            display_help();
            fprintf(stderr, "Unrecognized option: '%s'\n", arg);
            exit(1);
        }
    }

}

int
main(int argc, char **argv)
{
    struct sigaction saAlarmHandler;

    printf(PACKAGE " version " VERSION "\n");
    process_args(argc, argv);
    disp = XOpenDisplay(0);
    if (!disp) {
	fprintf(stderr, "Error: Cannot connect to display!\n");
	exit(-1);
    }

    saAlarmHandler.sa_handler = (void*)alarmhandler;
    saAlarmHandler.sa_flags = SA_RESTART;

    sigaction(SIGALRM, &saAlarmHandler, NULL);

    setup_window();
    main_loop();
    return 0;
}