src/egl/main/eglscreen.c

   1 /*
   2  * Ideas for screen management extension to EGL.
   3  *
   4  * Each EGLDisplay has one or more screens (CRTs, Flat Panels, etc).
   5  * The screens' handles can be obtained with eglGetScreensMESA().
   6  *
   7  * A new kind of EGLSurface is possible- one which can be directly scanned
   8  * out on a screen.  Such a surface is created with eglCreateScreenSurface().
   9  *
  10  * To actually display a screen surface on a screen, the eglShowSurface()
  11  * function is called.
  12  */
  13
  14 #include <assert.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17
  18 #include "egldisplay.h"
  19 #include "eglcurrent.h"
  20 #include "eglmode.h"
  21 #include "eglconfig.h"
  22 #include "eglsurface.h"
  23 #include "eglscreen.h"
  24 #include "eglmutex.h"
  25
  26
  27 #ifdef EGL_MESA_screen_surface
  28
  29
  30 /* ugh, no atomic op? */
  31 static _EGL_DECLARE_MUTEX(_eglNextScreenHandleMutex);
  32 static EGLScreenMESA _eglNextScreenHandle = 1;
  33
  34
  35 /**
  36  * Return a new screen handle/ID.
  37  * NOTE: we never reuse these!
  38  */
  39 static EGLScreenMESA
  40 _eglAllocScreenHandle(void)
  41 {
  42    EGLScreenMESA s;
  43
  44    _eglLockMutex(&_eglNextScreenHandleMutex);
  45    s = _eglNextScreenHandle++;
  46    _eglUnlockMutex(&_eglNextScreenHandleMutex);
  47
  48    return s;
  49 }
  50
  51
  52 /**
  53  * Initialize an _EGLScreen object to default values.
  54  */
  55 void
  56 _eglInitScreen(_EGLScreen *screen)
  57 {
  58    memset(screen, 0, sizeof(_EGLScreen));
  59    screen->StepX = 1;
  60    screen->StepY = 1;
  61 }
  62
  63
  64 /**
  65  * Given a public screen handle, return the internal _EGLScreen object.
  66  */
  67 _EGLScreen *
  68 _eglLookupScreen(EGLScreenMESA screen, _EGLDisplay *display)
  69 {
  70    EGLint i;
  71
  72    if (!display || !display->Screens)
  73       return NULL;
  74
  75    for (i = 0; i < display->Screens->Size; i++) {
  76       _EGLScreen *scr = (_EGLScreen *) display->Screens->Elements[i];
  77       if (scr->Handle == screen)
  78          return scr;
  79    }
  80    return NULL;
  81 }
  82
  83
  84 /**
  85  * Add the given _EGLScreen to the display's list of screens.
  86  */
  87 void
  88 _eglAddScreen(_EGLDisplay *display, _EGLScreen *screen)
  89 {
  90    assert(display);
  91    assert(screen);
  92
  93    if (!display->Screens) {
  94       display->Screens = _eglCreateArray("Screen", 4);
  95       if (!display->Screens)
  96          return;
  97    }
  98    screen->Handle = _eglAllocScreenHandle();
  99    _eglAppendArray(display->Screens, (void *) screen);
 100 }
 101
 102
 103
 104 static EGLBoolean
 105 _eglFlattenScreen(void *elem, void *buffer)
 106 {
 107    _EGLScreen *scr = (_EGLScreen *) elem;
 108    EGLScreenMESA *handle = (EGLScreenMESA *) buffer;
 109    *handle = scr->Handle;
 110    return EGL_TRUE;
 111 }
 112
 113
 114 EGLBoolean
 115 _eglGetScreensMESA(_EGLDriver *drv, _EGLDisplay *display, EGLScreenMESA *screens,
 116                    EGLint max_screens, EGLint *num_screens)
 117 {
 118    *num_screens = _eglFlattenArray(display->Screens, (void *) screens,
 119          sizeof(screens[0]), max_screens, _eglFlattenScreen);
 120
 121    return EGL_TRUE;
 122 }
 123
 124
 125 /**
 126  * Set a screen's current display mode.
 127  * Note: mode = EGL_NO_MODE is valid (turns off the screen)
 128  *
 129  * This is just a placeholder function; drivers will always override
 130  * this with code that _really_ sets the mode.
 131  */
 132 EGLBoolean
 133 _eglScreenModeMESA(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *scrn,
 134                    _EGLMode *m)
 135 {
 136    scrn->CurrentMode = m;
 137    return EGL_TRUE;
 138 }
 139
 140
 141 /**
 142  * Set a screen's surface origin.
 143  */
 144 EGLBoolean
 145 _eglScreenPositionMESA(_EGLDriver *drv, _EGLDisplay *dpy,
 146                        _EGLScreen *scrn, EGLint x, EGLint y)
 147 {
 148    scrn->OriginX = x;
 149    scrn->OriginY = y;
 150
 151    return EGL_TRUE;
 152 }
 153
 154
 155 /**
 156  * Query a screen's current surface.
 157  */
 158 EGLBoolean
 159 _eglQueryScreenSurfaceMESA(_EGLDriver *drv, _EGLDisplay *dpy,
 160                            _EGLScreen *scrn, _EGLSurface **surf)
 161 {
 162    *surf = scrn->CurrentSurface;
 163    return EGL_TRUE;
 164 }
 165
 166
 167 /**
 168  * Query a screen's current mode.
 169  */
 170 EGLBoolean
 171 _eglQueryScreenModeMESA(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *scrn,
 172                         _EGLMode **m)
 173 {
 174    *m = scrn->CurrentMode;
 175    return EGL_TRUE;
 176 }
 177
 178
 179 EGLBoolean
 180 _eglQueryScreenMESA(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *scrn,
 181                     EGLint attribute, EGLint *value)
 182 {
 183    switch (attribute) {
 184    case EGL_SCREEN_POSITION_MESA:
 185       value[0] = scrn->OriginX;
 186       value[1] = scrn->OriginY;
 187       break;
 188    case EGL_SCREEN_POSITION_GRANULARITY_MESA:
 189       value[0] = scrn->StepX;
 190       value[1] = scrn->StepY;
 191       break;
 192    default:
 193       _eglError(EGL_BAD_ATTRIBUTE, "eglQueryScreenMESA");
 194       return EGL_FALSE;
 195    }
 196
 197    return EGL_TRUE;
 198 }
 199
 200
 201 /**
 202  * Delete the modes associated with given screen.
 203  */
 204 void
 205 _eglDestroyScreenModes(_EGLScreen *scrn)
 206 {
 207    EGLint i;
 208    for (i = 0; i < scrn->NumModes; i++) {
 209       if (scrn->Modes[i].Name)
 210          free((char *) scrn->Modes[i].Name); /* cast away const */
 211    }
 212    if (scrn->Modes)
 213       free(scrn->Modes);
 214    scrn->Modes = NULL;
 215    scrn->NumModes = 0;
 216 }
 217
 218
 219 /**
 220  * Default fallback routine - drivers should usually override this.
 221  */
 222 void
 223 _eglDestroyScreen(_EGLScreen *scrn)
 224 {
 225    _eglDestroyScreenModes(scrn);
 226    free(scrn);
 227 }
 228
 229
 230 #endif /* EGL_MESA_screen_surface */