Logo Search packages:      
Sourcecode: beryl-plugins version File versions

bench.c

/**
 *
 * Beryl benchmark plugin
 *
 * bench.c
 *
 * Copyright : (C) 2006 by Dennis Kasprzyk
 * E-mail    : onestone@beryl-project.org
 *
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 **/

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <math.h>
#include <X11/Xatom.h>
#include <X11/extensions/Xrender.h>
#include <beryl.h>

#include "bench_tex.h"

#define GET_BENCH_DISPLAY(d)                                  \
    ((BenchDisplay *) (d)->privates[displayPrivateIndex].ptr)

#define BENCH_DISPLAY(d)                      \
    BenchDisplay *bd = GET_BENCH_DISPLAY (d)

#define GET_BENCH_SCREEN(s, bd)                                   \
    ((BenchScreen *) (s)->privates[(bd)->screenPrivateIndex].ptr)

#define BENCH_SCREEN(s)                                                      \
    BenchScreen *bs = GET_BENCH_SCREEN (s, GET_BENCH_DISPLAY (s->display))

#define TIMEVALDIFF(tv1, tv2)                                              \
    (((tv1)->tv_sec == (tv2)->tv_sec || (tv1)->tv_usec >= (tv2)->tv_usec) ? \
     ((((tv1)->tv_sec - (tv2)->tv_sec) * 1000000) +                         \
      ((tv1)->tv_usec - (tv2)->tv_usec)) / 1000 :                           \
     ((((tv1)->tv_sec - 1 - (tv2)->tv_sec) * 1000000) +                     \
      (1000000 + (tv1)->tv_usec - (tv2)->tv_usec)) / 1000)

#define TIMEVALDIFFU(tv1, tv2)                                              \
    (((tv1)->tv_sec == (tv2)->tv_sec || (tv1)->tv_usec >= (tv2)->tv_usec) ? \
     ((((tv1)->tv_sec - (tv2)->tv_sec) * 1000000) +                      \
      ((tv1)->tv_usec - (tv2)->tv_usec)):                                   \
     ((((tv1)->tv_sec - 1 - (tv2)->tv_sec) * 1000000) +                  \
      (1000000 + (tv1)->tv_usec - (tv2)->tv_usec)))

#ifdef GL_DEBUG
static GLenum gl_error;

#define GLERR  gl_error=glGetError(); if (gl_error !=  GL_NO_ERROR) { fprintf (stderr,"GL error 0x%X has occured at %s:%d\n",gl_error,__FILE__,__LINE__); }
#else
#define GLERR
#endif

#define BENCH_DISPLAY_OPTION_INITIATE                       0
#define BENCH_DISPLAY_OPTION_DISABLE_LIMIT                  1
#define BENCH_DISPLAY_OPTION_POS_X                          2
#define BENCH_DISPLAY_OPTION_POS_Y                          3
#define BENCH_DISPLAY_OPTION_OUTPUT_SCREEN                  4
#define BENCH_DISPLAY_OPTION_OUTPUT_CONSOLE                 5
#define BENCH_DISPLAY_OPTION_CONSOLE_UPDATE_TIME            6
#define BENCH_DISPLAY_OPTION_NUM                            7

#define BENCH_DISPLAY_OPTION_DISABLE_LIMIT_DEFAULT          TRUE
#define BENCH_DISPLAY_OPTION_POS_X_DEFAULT                  0
#define BENCH_DISPLAY_OPTION_POS_Y_DEFAULT                  0
#define BENCH_DISPLAY_OPTION_OUTPUT_SCREEN_DEFAULT          TRUE
#define BENCH_DISPLAY_OPTION_OUTPUT_CONSOLE_DEFAULT         FALSE
#define BENCH_DISPLAY_OPTION_CONSOLE_UPDATE_TIME_DEFAULT    5


#define BENCH_DISPLAY_OPTION_INITIATE_KEY                   "F12"
#define BENCH_DISPLAY_OPTION_INITIATE_MOD                   CompSuperMask

#define NUM_OPTIONS(s) (sizeof ((s)->opt) / sizeof (CompOption))

static int displayPrivateIndex = 0;

typedef struct _BenchDisplay
{
      int screenPrivateIndex;
      Bool active;

      CompOption opt[BENCH_DISPLAY_OPTION_NUM];
} BenchDisplay;

typedef struct _BenchScreen
{
      GLuint dList;
      float rrVal;
      float fps;
      float alpha;
      struct timeval initTime;
      struct timeval lastRedraw;
      float ctime;
      float frames;

      GLuint numTex[10];
      GLuint backTex;

      PreparePaintScreenProc preparePaintScreen;
      DonePaintScreenProc donePaintScreen;
      PaintScreenProc paintScreen;

} BenchScreen;

static void benchPreparePaintScreen(CompScreen * s, int msSinceLastPaint)
{
      BENCH_SCREEN(s);
      BENCH_DISPLAY(s->display);

      float nRrVal;
      float ratio = 0.05;
      int timediff;
      struct timeval now;

      gettimeofday(&now, 0);

      timediff = TIMEVALDIFF(&now, &bs->lastRedraw);

      nRrVal = MIN(1.1, (float)s->optimalRedrawTime / (float)timediff);

      bs->rrVal = (bs->rrVal * (1.0 - ratio)) + (nRrVal * ratio);

      bs->fps =
                  (bs->fps * (1.0 - ratio)) +
                  (1000000.0 / TIMEVALDIFFU(&now, &bs->lastRedraw) * ratio);

      bs->lastRedraw = now;

      if (bd->opt[BENCH_DISPLAY_OPTION_OUTPUT_CONSOLE].value.b && bd->active)
      {
            bs->frames++;
            bs->ctime += timediff;
            if (bs->ctime >
                  bd->opt[BENCH_DISPLAY_OPTION_CONSOLE_UPDATE_TIME].value.i * 1000)
            {
                  printf("[BENCH] : %.0f frames in %.1f seconds = %.3f FPS\n",
                           bs->frames, bs->ctime / 1000.0,
                           bs->frames / (bs->ctime / 1000.0));
                  bs->frames = 0;
                  bs->ctime = 0;
            }
      }

      UNWRAP(bs, s, preparePaintScreen);
      (*s->preparePaintScreen) (s,
                                            (bs->alpha >
                                             0.0) ? timediff : msSinceLastPaint);
      WRAP(bs, s, preparePaintScreen, benchPreparePaintScreen);

      if (bd->active)
            bs->alpha += timediff / 1000.0;
      else
            bs->alpha -= timediff / 1000.0;

      bs->alpha = MIN(1.0, MAX(0.0, bs->alpha));
}

static void benchDonePaintScreen(CompScreen * s)
{
      BENCH_SCREEN(s);
      BENCH_DISPLAY(s->display);

      if (bs->alpha > 0.0)
      {
            damageScreen(s);
            glFlush();
            XSync(s->display->display, FALSE);
            if (bd->opt[BENCH_DISPLAY_OPTION_DISABLE_LIMIT].value.b)
            {
                  s->lastRedraw = bs->initTime;
                  s->timeMult = 0;
            }
            if (!bd->active)
                  s->timeMult = 0;
      }
      UNWRAP(bs, s, donePaintScreen);
      (*s->donePaintScreen) (s);
      WRAP(bs, s, donePaintScreen, benchDonePaintScreen);
}


static Bool
benchPaintScreen(CompScreen * s, const ScreenPaintAttrib * sa,
                         Region region, int output, unsigned int mask)
{

      Bool status, isSet;
      unsigned int fps;

      BENCH_SCREEN(s);
      BENCH_DISPLAY(s->display);

      UNWRAP(bs, s, paintScreen);
      status = (*s->paintScreen) (s, sa, region, output, mask);
      WRAP(bs, s, paintScreen, benchPaintScreen);

      if (bs->alpha <= 0.0
            || !bd->opt[BENCH_DISPLAY_OPTION_OUTPUT_SCREEN].value.b)
            return status;
      glGetError();
      glPushAttrib(GL_COLOR_BUFFER_BIT | GL_TEXTURE_BIT);
      GLERR;

      glPushMatrix();
      glLoadIdentity();
      prepareXCoords(s, output, -DEFAULT_Z_CAMERA);

      glEnable(GL_BLEND);
      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

      glColor4f(1.0, 1.0, 1.0, bs->alpha);

      glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

      glTranslatef(bd->opt[BENCH_DISPLAY_OPTION_POS_X].value.i,
                         bd->opt[BENCH_DISPLAY_OPTION_POS_Y].value.i, 0);

      glEnable(GL_TEXTURE_2D);
      glBindTexture(GL_TEXTURE_2D, bs->backTex);

      glBegin(GL_QUADS);
      glTexCoord2f(0, 0);
      glVertex2f(0, 0);
      glTexCoord2f(0, 1);
      glVertex2f(0, 256);
      glTexCoord2f(1, 1);
      glVertex2f(512, 256);
      glTexCoord2f(1, 0);
      glVertex2f(512, 0);
      glEnd();

      glBindTexture(GL_TEXTURE_2D, 0);
      glDisable(GL_TEXTURE_2D);


      glTranslatef(53, 83, 0);
      float rrVal = MIN(1.0, MAX(0.0, bs->rrVal));

      if (rrVal < 0.5)
      {

            glBegin(GL_QUADS);
            glColor4f(1.0, 0.0, 0.0, bs->alpha);
            glVertex2f(0.0, 0.0);
            glVertex2f(0.0, 25.0);
            glColor4f(1.0, rrVal * 2.0, 0.0, bs->alpha);
            glVertex2f(330.0 * rrVal, 25.0);
            glVertex2f(330.0 * rrVal, 0.0);
            glEnd();
      }
      else
      {

            glBegin(GL_QUADS);
            glColor4f(1.0, 0.0, 0.0, bs->alpha);
            glVertex2f(0.0, 0.0);
            glVertex2f(0.0, 25.0);
            glColor4f(1.0, 1.0, 0.0, bs->alpha);
            glVertex2f(165.0, 25.0);
            glVertex2f(165.0, 0.0);
            glEnd();

            glBegin(GL_QUADS);
            glColor4f(1.0, 1.0, 0.0, bs->alpha);
            glVertex2f(165.0, 0.0);
            glVertex2f(165.0, 25.0);
            glColor4f(1.0 - ((rrVal - 0.5) * 2.0), 1.0, 0.0, bs->alpha);
            glVertex2f(165.0 + 330.0 * (rrVal - 0.5), 25.0);
            glVertex2f(165.0 + 330.0 * (rrVal - 0.5), 0.0);
            glEnd();

      }

      glColor4f(0.0, 0.0, 0.0, bs->alpha);

      glCallList(bs->dList);

      glTranslatef(72, 45, 0);

      float red;

      if (bs->fps > 30.0)
            red = 0.0;
      else
            red = 1.0;
      if (bs->fps <= 30.0 && bs->fps > 20.0)
            red = 1.0 - ((bs->fps - 20.0) / 10.0);

      glColor4f(red, 0.0, 0.0, bs->alpha);

      glEnable(GL_TEXTURE_2D);
      isSet = FALSE;
      fps = (bs->fps * 100.0);
      fps = MIN(999999, fps);

      if (fps >= 100000)
      {
            glBindTexture(GL_TEXTURE_2D, bs->numTex[fps / 100000]);
            glCallList(bs->dList + 1);
            isSet = TRUE;
      }
      fps %= 100000;
      glTranslatef(12, 0, 0);
      if (fps >= 10000 || isSet)
      {
            glBindTexture(GL_TEXTURE_2D, bs->numTex[fps / 10000]);
            glCallList(bs->dList + 1);
            isSet = TRUE;
      }
      fps %= 10000;
      glTranslatef(12, 0, 0);
      if (fps >= 1000 || isSet)
      {
            glBindTexture(GL_TEXTURE_2D, bs->numTex[fps / 1000]);
            glCallList(bs->dList + 1);
      }
      fps %= 1000;
      glTranslatef(12, 0, 0);

      glBindTexture(GL_TEXTURE_2D, bs->numTex[fps / 100]);
      glCallList(bs->dList + 1);
      fps %= 100;

      glTranslatef(19, 0, 0);

      glBindTexture(GL_TEXTURE_2D, bs->numTex[fps / 10]);
      glCallList(bs->dList + 1);
      fps %= 10;

      glTranslatef(12, 0, 0);

      glBindTexture(GL_TEXTURE_2D, bs->numTex[fps]);
      glCallList(bs->dList + 1);

      glBindTexture(GL_TEXTURE_2D, 0);
      glDisable(GL_TEXTURE_2D);

      glPopMatrix();

      glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

      glColor4f(1.0, 1.0, 1.0, 1.0);

      glPopAttrib();
      glGetError();

      return status;
}

static Bool benchInitScreen(CompPlugin * p, CompScreen * s)
{
      int i;

      BENCH_DISPLAY(s->display);

      BenchScreen *bs = (BenchScreen *) calloc(1, sizeof(BenchScreen));

      s->privates[bd->screenPrivateIndex].ptr = bs;

      WRAP(bs, s, paintScreen, benchPaintScreen);
      WRAP(bs, s, preparePaintScreen, benchPreparePaintScreen);
      WRAP(bs, s, donePaintScreen, benchDonePaintScreen);

      glGenTextures(10, bs->numTex);
      glGenTextures(1, &bs->backTex);

      glGetError();

      glEnable(GL_TEXTURE_2D);

      bs->alpha = 0;
      bs->ctime = 0;
      bs->frames = 0;

      for (i = 0; i < 10; i++)
      {
            //Bind the texture
            glBindTexture(GL_TEXTURE_2D, bs->numTex[i]);

            //Load the parameters
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

            glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 16, 32, 0,
                               GL_RGBA, GL_UNSIGNED_BYTE, number_data[i]);
            GLERR;
      }

      glBindTexture(GL_TEXTURE_2D, bs->backTex);

      //Load the parameters
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

      glTexImage2D(GL_TEXTURE_2D, 0, 4, 512, 256, 0, GL_RGBA,
                         GL_UNSIGNED_BYTE, image_data);
      GLERR;

      glBindTexture(GL_TEXTURE_2D, 0);
      glDisable(GL_TEXTURE_2D);

      bs->dList = glGenLists(2);
      glNewList(bs->dList, GL_COMPILE);

      glLineWidth(2.0);

      glBegin(GL_LINE_LOOP);
      glVertex2f(0, 0);
      glVertex2f(0, 25);
      glVertex2f(330, 25);
      glVertex2f(330, 0);
      glEnd();

      glLineWidth(1.0);

      glBegin(GL_LINES);
      for (i = 33; i < 330; i += 33)
      {
            glVertex2f(i, 15);
            glVertex2f(i, 25);
      }
      for (i = 16; i < 330; i += 33)
      {
            glVertex2f(i, 20);
            glVertex2f(i, 25);
      }
      glEnd();

      glEndList();

      glNewList(bs->dList + 1, GL_COMPILE);
      glBegin(GL_QUADS);
      glTexCoord2f(0, 0);
      glVertex2f(0, 0);
      glTexCoord2f(0, 1);
      glVertex2f(0, 32);
      glTexCoord2f(1, 1);
      glVertex2f(16, 32);
      glTexCoord2f(1, 0);
      glVertex2f(16, 0);
      glEnd();
      glEndList();


      gettimeofday(&bs->initTime, 0);
      gettimeofday(&bs->lastRedraw, 0);

      addScreenAction(s, &bd->opt[BENCH_DISPLAY_OPTION_INITIATE].value.action);

      return TRUE;
}


static void benchFiniScreen(CompPlugin * p, CompScreen * s)
{

      BENCH_SCREEN(s);
      BENCH_DISPLAY(s->display);
      glDeleteLists(bs->dList, 2);

      glDeleteTextures(10, bs->numTex);
      glDeleteTextures(1, &bs->backTex);

      //Restore the original function
      UNWRAP(bs, s, paintScreen);
      UNWRAP(bs, s, preparePaintScreen);
      UNWRAP(bs, s, donePaintScreen);

      removeScreenAction(s,
                                 &bd->opt[BENCH_DISPLAY_OPTION_INITIATE].value.action);

      //Free the pointer
      free(bs);

}

static Bool
benchSetDisplayOption(CompDisplay * display, char *name,
                                CompOptionValue * value)
{
      CompOption *o;
      int index;

      BENCH_DISPLAY(display);

      o = compFindOption(bd->opt, NUM_OPTIONS(bd), name, &index);
      if (!o)
            return FALSE;

      switch (index)
      {
      case BENCH_DISPLAY_OPTION_INITIATE:
            if (setDisplayAction(display, o, value))
                  return TRUE;
            break;
      case BENCH_DISPLAY_OPTION_DISABLE_LIMIT:
      case BENCH_DISPLAY_OPTION_OUTPUT_SCREEN:
      case BENCH_DISPLAY_OPTION_OUTPUT_CONSOLE:
            if (compSetBoolOption(o, value))
                  return TRUE;
            break;
      case BENCH_DISPLAY_OPTION_POS_X:
      case BENCH_DISPLAY_OPTION_POS_Y:
      case BENCH_DISPLAY_OPTION_CONSOLE_UPDATE_TIME:
            if (compSetIntOption(o, value))
                  return TRUE;
            break;

      default:
            break;
      }

      return FALSE;
}

static Bool
benchInitiate(CompDisplay * d, CompAction * ac, CompActionState state,
                    CompOption * option, int nOption)
{
      CompScreen *s;

      BENCH_DISPLAY(d);
      bd->active = !bd->active;
      bd->active &= bd->opt[BENCH_DISPLAY_OPTION_OUTPUT_SCREEN].value.b
                  || bd->opt[BENCH_DISPLAY_OPTION_OUTPUT_CONSOLE].value.b;
      s = findScreenAtDisplay(d, getIntOptionNamed(option, nOption, "root", 0));
      if (s)
      {
            BENCH_SCREEN(s);
            damageScreen(s);
            bs->ctime = 0;
            bs->frames = 0;
      }
      return FALSE;
}

static void benchDisplayInitOptions(BenchDisplay * bd)
{
      CompOption *o;

      o = &bd->opt[BENCH_DISPLAY_OPTION_INITIATE];
      o->advanced = False;
      o->name = "initiate";
      o->group = N_("Main");
      o->subGroup = N_("");
      o->displayHints = "";
      o->shortDesc = N_("Initiate");
      o->longDesc = N_("Start benchmark");
      o->type = CompOptionTypeAction;
      o->value.action.initiate = benchInitiate;
      o->value.action.terminate = 0;
      o->value.action.bell = FALSE;
      o->value.action.edgeMask = 0;
      o->value.action.type = CompBindingTypeKey;
      o->value.action.state = CompActionStateInitKey;
      o->value.action.key.modifiers = BENCH_DISPLAY_OPTION_INITIATE_MOD;
      o->value.action.key.keysym =
                  XStringToKeysym(BENCH_DISPLAY_OPTION_INITIATE_KEY);

      o = &bd->opt[BENCH_DISPLAY_OPTION_OUTPUT_SCREEN];
      o->advanced = False;
      o->name = "output_screen";
      o->group = N_("Main");
      o->subGroup = N_("Screen Output");
      o->displayHints = "";
      o->shortDesc = N_("Enable");
      o->longDesc = N_("Display FPS on screen");
      o->type = CompOptionTypeBool;
      o->value.b = BENCH_DISPLAY_OPTION_OUTPUT_SCREEN_DEFAULT;

      o = &bd->opt[BENCH_DISPLAY_OPTION_OUTPUT_CONSOLE];
      o->advanced = False;
      o->name = "output_console";
      o->group = N_("Main");
      o->subGroup = N_("Console Output");
      o->displayHints = "";
      o->shortDesc = N_("Enable");
      o->longDesc = N_("Print FPS to console");
      o->type = CompOptionTypeBool;
      o->value.b = BENCH_DISPLAY_OPTION_OUTPUT_CONSOLE_DEFAULT;

      o = &bd->opt[BENCH_DISPLAY_OPTION_CONSOLE_UPDATE_TIME];
      o->advanced = False;
      o->name = "console_update_time";
      o->group = N_("Main");
      o->subGroup = N_("Console Output");
      o->displayHints = "";
      o->shortDesc = N_("Update time");
      o->longDesc = N_("Console output update time");
      o->type = CompOptionTypeInt;
      o->value.i = BENCH_DISPLAY_OPTION_CONSOLE_UPDATE_TIME_DEFAULT;
      o->rest.i.min = 1;
      o->rest.i.max = 60;

      o = &bd->opt[BENCH_DISPLAY_OPTION_DISABLE_LIMIT];
      o->advanced = False;
      o->name = "disable_limiter";
      o->group = N_("Main");
      o->subGroup = N_("");
      o->displayHints = "";
      o->shortDesc = N_("Disable limiter");
      o->longDesc = N_("Disable beryl integrated FPS limiter");
      o->type = CompOptionTypeBool;
      o->value.b = BENCH_DISPLAY_OPTION_DISABLE_LIMIT_DEFAULT;

      o = &bd->opt[BENCH_DISPLAY_OPTION_POS_X];
      o->advanced = False;
      o->name = "position_x";
      o->group = N_("Main");
      o->subGroup = N_("Screen Output");
      o->displayHints = "";
      o->shortDesc = N_("X position");
      o->longDesc = N_("X Position of benchmark window");
      o->type = CompOptionTypeInt;
      o->value.i = BENCH_DISPLAY_OPTION_POS_X_DEFAULT;
      o->rest.i.min = 0;
      o->rest.i.max = 4096;

      o = &bd->opt[BENCH_DISPLAY_OPTION_POS_Y];
      o->advanced = False;
      o->name = "position_y";
      o->group = N_("Main");
      o->subGroup = N_("Screen Output");
      o->displayHints = "";
      o->shortDesc = N_("Y position");
      o->longDesc = N_("Y Position of benchmark window");
      o->type = CompOptionTypeInt;
      o->value.i = BENCH_DISPLAY_OPTION_POS_X_DEFAULT;
      o->rest.i.min = 0;
      o->rest.i.max = 4096;
}

static CompOption *benchGetDisplayOptions(CompDisplay * display, int *count)
{
      if (display)
      {
            BENCH_DISPLAY(display);

            *count = NUM_OPTIONS(bd);
            return bd->opt;
      }
      else
      {
            BenchDisplay *bd = malloc(sizeof(BenchDisplay));

            benchDisplayInitOptions(bd);
            *count = NUM_OPTIONS(bd);
            return bd->opt;
      }
}



static Bool benchInitDisplay(CompPlugin * p, CompDisplay * d)
{
      //Generate a bench display
      BenchDisplay *bd = (BenchDisplay *) malloc(sizeof(BenchDisplay));

      //Allocate a private index
      bd->screenPrivateIndex = allocateScreenPrivateIndex(d);
      //Check if its valid
      if (bd->screenPrivateIndex < 0)
      {
            //Its invalid so free memory and return
            free(bd);
            return FALSE;
      }
      benchDisplayInitOptions(bd);
      bd->active = FALSE;
      //Record the display
      d->privates[displayPrivateIndex].ptr = bd;
      return TRUE;
}

static void benchFiniDisplay(CompPlugin * p, CompDisplay * d)
{
      BENCH_DISPLAY(d);
      //Free the private index
      freeScreenPrivateIndex(d, bd->screenPrivateIndex);
      //Free the pointer
      free(bd);
}



static Bool benchInit(CompPlugin * p)
{
      displayPrivateIndex = allocateDisplayPrivateIndex();

      if (displayPrivateIndex < 0)
            return FALSE;

      return TRUE;
}

static void benchFini(CompPlugin * p)
{
      if (displayPrivateIndex >= 0)
            freeDisplayPrivateIndex(displayPrivateIndex);
}


CompPluginVTable benchVTable = {
      "bench",
      N_("Benchmark"),
      N_("A simple benchmark plugin"),
      benchInit,
      benchFini,
      benchInitDisplay,
      benchFiniDisplay,
      benchInitScreen,
      benchFiniScreen,
      0,
      0,
      benchGetDisplayOptions,
      benchSetDisplayOption,
      0,
      0,
      0,
      0,
      0,
      0,
      BERYL_ABI_INFO,
      "beryl-plugins",
      "misc",
      0,
      0,
      False,
};

CompPluginVTable *getCompPluginInfo(void)
{
      return &benchVTable;
}

Generated by  Doxygen 1.6.0   Back to index