From ad6f8eba00359fcb7abff8105dcb7a9dd2f32fec Mon Sep 17 00:00:00 2001 From: Brian Paul Date: Sat, 10 Dec 2005 17:52:11 +0000 Subject: [PATCH] lots of updates, mode sorting, etc --- src/egl/main/eglmode.c | 338 ++++++++++++++++++++++++++++++++++------- src/egl/main/eglmode.h | 7 +- 2 files changed, 289 insertions(+), 56 deletions(-) diff --git a/src/egl/main/eglmode.c b/src/egl/main/eglmode.c index f2b17a6d270..786432234bb 100644 --- a/src/egl/main/eglmode.c +++ b/src/egl/main/eglmode.c @@ -1,3 +1,4 @@ +#include #include #include #include @@ -15,10 +16,16 @@ static char * my_strdup(const char *s) { - int l = strlen(s); - char *s2 = malloc(l + 1); - strcpy(s2, s); - return s2; + if (s) { + int l = strlen(s); + char *s2 = malloc(l + 1); + if (s2) + strcpy(s2, s); + return s2; + } + else { + return NULL; + } } @@ -55,8 +62,8 @@ _eglLookupMode(EGLDisplay dpy, EGLModeMESA mode) * \return pointer to the new _EGLMode */ _EGLMode * -_eglAddMode(_EGLScreen *screen, EGLint width, EGLint height, - EGLint refreshRate, const char *name) +_eglAddNewMode(_EGLScreen *screen, EGLint width, EGLint height, + EGLint refreshRate, const char *name) { EGLint n; _EGLMode *newModes; @@ -74,7 +81,8 @@ _eglAddMode(_EGLScreen *screen, EGLint width, EGLint height, screen->Modes[n].Width = width; screen->Modes[n].Height = height; screen->Modes[n].RefreshRate = refreshRate; - screen->Modes[n].Stereo = EGL_FALSE; + screen->Modes[n].Optimal = EGL_FALSE; + screen->Modes[n].Interlaced = EGL_FALSE; screen->Modes[n].Name = my_strdup(name); screen->NumModes++; return screen->Modes + n; @@ -87,38 +95,226 @@ _eglAddMode(_EGLScreen *screen, EGLint width, EGLint height, /** - * Search for the EGLMode that best matches the given attribute list. + * Parse the attrib_list to fill in the fields of the given _eglMode + * Return EGL_FALSE if any errors, EGL_TRUE otherwise. */ -EGLBoolean -_eglChooseModeMESA(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA screen, - const EGLint *attrib_list, EGLModeMESA *modes, - EGLint modes_size, EGLint *num_modes) +static EGLBoolean +_eglParseModeAttribs(_EGLMode *mode, const EGLint *attrib_list) { EGLint i; - /* XXX incomplete */ + /* init all attribs to EGL_DONT_CARE */ + mode->Handle = EGL_DONT_CARE; + mode->Width = EGL_DONT_CARE; + mode->Height = EGL_DONT_CARE; + mode->RefreshRate = EGL_DONT_CARE; + mode->Optimal = EGL_DONT_CARE; + mode->Interlaced = EGL_DONT_CARE; + mode->Name = NULL; - for (i = 0; attrib_list[i] != EGL_NONE; i++) { + for (i = 0; attrib_list && attrib_list[i] != EGL_NONE; i++) { switch (attrib_list[i]) { + case EGL_MODE_ID_MESA: + mode->Handle = attrib_list[++i]; + if (mode->Handle <= 0) { + _eglError(EGL_BAD_PARAMETER, "eglChooseModeMESA(handle)"); + return EGL_FALSE; + } + break; case EGL_WIDTH: - i++; + mode->Width = attrib_list[++i]; + if (mode->Width <= 0) { + _eglError(EGL_BAD_PARAMETER, "eglChooseModeMESA(width)"); + return EGL_FALSE; + } break; case EGL_HEIGHT: - i++; + mode->Height = attrib_list[++i]; + if (mode->Height <= 0) { + _eglError(EGL_BAD_PARAMETER, "eglChooseModeMESA(height)"); + return EGL_FALSE; + } break; case EGL_REFRESH_RATE_MESA: - i++; + mode->RefreshRate = attrib_list[++i]; + if (mode->RefreshRate <= 0) { + _eglError(EGL_BAD_PARAMETER, "eglChooseModeMESA(refresh rate)"); + return EGL_FALSE; + } break; -#if 0 - case EGL_STEREO_MESA: - i++; + case EGL_INTERLACED_MESA: + mode->Interlaced = attrib_list[++i]; + if (mode->Interlaced != EGL_TRUE && mode->Interlaced != EGL_FALSE) { + _eglError(EGL_BAD_PARAMETER, "eglChooseModeMESA(interlaced)"); + return EGL_FALSE; + } + break; + case EGL_OPTIMAL_MESA: + mode->Optimal = attrib_list[++i]; + if (mode->Optimal != EGL_TRUE && mode->Optimal != EGL_FALSE) { + _eglError(EGL_BAD_PARAMETER, "eglChooseModeMESA(optimal)"); + return EGL_FALSE; + } break; -#endif default: - _eglError(EGL_BAD_ATTRIBUTE, "eglChooseMode"); + _eglError(EGL_BAD_ATTRIBUTE, "eglChooseModeMESA"); return EGL_FALSE; } } + return EGL_TRUE; +} + + +/** + * Determine if the candidate mode's attributes are at least as good + * as the minimal mode's. + * \return EGL_TRUE if qualifies, EGL_FALSE otherwise + */ +static EGLBoolean +_eglModeQualifies(const _EGLMode *c, const _EGLMode *min) +{ + if (min->Handle != EGL_DONT_CARE && c->Handle != min->Handle) + return EGL_FALSE; + if (min->Width != EGL_DONT_CARE && c->Width < min->Width) + return EGL_FALSE; + if (min->Height != EGL_DONT_CARE && c->Height < min->Height) + return EGL_FALSE; + if (min->RefreshRate != EGL_DONT_CARE && c->RefreshRate < min->RefreshRate) + return EGL_FALSE; + if (min->Optimal != EGL_DONT_CARE && c->Optimal != min->Optimal) + return EGL_FALSE; + if (min->Interlaced != EGL_DONT_CARE && c->Interlaced != min->Interlaced) + return EGL_FALSE; + + return EGL_TRUE; +} + + +/** + * Return value of given mode attribute, or -1 if bad attrib. + */ +static EGLint +getModeAttrib(const _EGLMode *m, EGLint attrib) +{ + switch (attrib) { + case EGL_MODE_ID_MESA: + return m->Handle; + case EGL_WIDTH: + return m->Width; + case EGL_HEIGHT: + return m->Height; + case EGL_REFRESH_RATE_MESA: + return m->RefreshRate; + case EGL_OPTIMAL_MESA: + return m->Optimal; + case EGL_INTERLACED_MESA: + return m->Interlaced; + default: + return -1; + } +} + + +#define SMALLER 1 +#define LARGER 2 + +struct sort_info { + EGLint Attrib; + EGLint Order; /* SMALLER or LARGER */ +}; + +/* the order of these entries is the priority */ +static struct sort_info SortInfo[] = { + { EGL_OPTIMAL_MESA, LARGER }, + { EGL_INTERLACED_MESA, SMALLER }, + { EGL_WIDTH, LARGER }, + { EGL_HEIGHT, LARGER }, + { EGL_REFRESH_RATE_MESA, LARGER }, + { EGL_MODE_ID_MESA, SMALLER }, + { 0, 0 } +}; + + +/** + * Compare modes 'a' and 'b' and return -1 if a belongs before b, or 1 if a + * belongs after b, or 0 if they're equal. + * Used by qsort(). + */ +static int +_eglCompareModes(const void *a, const void *b) +{ + const _EGLMode *aMode = *((const _EGLMode **) a); + const _EGLMode *bMode = *((const _EGLMode **) b); + EGLint i; + + for (i = 0; SortInfo[i].Attrib; i++) { + const EGLint aVal = getModeAttrib(aMode, SortInfo[i].Attrib); + const EGLint bVal = getModeAttrib(bMode, SortInfo[i].Attrib); + if (aVal == bVal) { + /* a tie */ + continue; + } + else if (SortInfo[i].Order == SMALLER) { + return (aVal < bVal) ? -1 : 1; + } + else if (SortInfo[i].Order == LARGER) { + return (aVal > bVal) ? -1 : 1; + } + } + + /* all attributes identical */ + return 0; +} + + +/** + * Search for EGLModes which match the given attribute list. + * Called via eglChooseModeMESA API function. + */ +EGLBoolean +_eglChooseModeMESA(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA screen, + const EGLint *attrib_list, EGLModeMESA *modes, + EGLint modes_size, EGLint *num_modes) +{ + const _EGLScreen *scrn = _eglLookupScreen(dpy, screen); + _EGLMode **modeList, min; + EGLint i, count; + + if (!scrn) { + _eglError(EGL_BAD_SCREEN_MESA, "eglChooseModeMESA"); + return EGL_FALSE; + } + + if (!_eglParseModeAttribs(&min, attrib_list)) { + /* error code will have been recorded */ + return EGL_FALSE; + } + + /* allocate array of mode pointers */ + modeList = (_EGLMode **) malloc(modes_size * sizeof(_EGLMode *)); + if (!modeList) { + _eglError(EGL_BAD_MODE_MESA, "eglChooseModeMESA(out of memory)"); + return EGL_FALSE; + } + + /* make array of pointers to qualifying modes */ + for (i = count = 0; i < scrn->NumModes && count < modes_size; i++) { + if (_eglModeQualifies(scrn->Modes + i, &min)) { + modeList[count++] = scrn->Modes + i; + } + } + + /* sort array of pointers */ + qsort(modeList, count, sizeof(_EGLMode *), _eglCompareModes); + + /* copy mode handles to output array */ + for (i = 0; i < count; i++) { + modes[i] = modeList[i]->Handle; + } + + free(modeList); + + *num_modes = count; return EGL_TRUE; } @@ -126,23 +322,30 @@ _eglChooseModeMESA(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA screen, /** - * Return all possible modes for the given screen + * Return all possible modes for the given screen. No sorting of results. + * Called via eglGetModesMESA() API function. */ EGLBoolean _eglGetModesMESA(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA screen, EGLModeMESA *modes, EGLint modes_size, EGLint *num_modes) { _EGLScreen *scrn = _eglLookupScreen(dpy, screen); - EGLint i; if (!scrn) { - _eglError(EGL_BAD_SCREEN_MESA, "eglGetModes"); + _eglError(EGL_BAD_SCREEN_MESA, "eglGetModesMESA"); return EGL_FALSE; } - *num_modes = MIN2(modes_size, scrn->NumModes); - for (i = 0; i < *num_modes; i++) { - modes[i] = scrn->Modes[i].Handle; + if (modes) { + EGLint i; + *num_modes = MIN2(scrn->NumModes, modes_size); + for (i = 0; i < *num_modes; i++) { + modes[i] = scrn->Modes[i].Handle; + } + } + else { + /* just return total number of supported modes */ + *num_modes = scrn->NumModes; } return EGL_TRUE; @@ -157,43 +360,72 @@ _eglGetModeAttribMESA(_EGLDriver *drv, EGLDisplay dpy, EGLModeMESA mode, EGLint attribute, EGLint *value) { _EGLMode *m = _eglLookupMode(dpy, mode); + EGLint v; - switch (attribute) { - case EGL_MODE_ID_MESA: - *value = m->Handle; - break; - case EGL_WIDTH: - *value = m->Width; - break; - case EGL_HEIGHT: - *value = m->Height; - break; -#if 0 - case EGL_DEPTH_MESA: - *value = m->Depth; - break; -#endif - case EGL_REFRESH_RATE_MESA: - *value = m->RefreshRate; - break; -#if 0 - case EGL_STEREO_MESA: - *value = m->Stereo; - break; -#endif - default: - _eglError(EGL_BAD_ATTRIBUTE, "eglGetModeAttrib"); + if (!m) { + _eglError(EGL_BAD_MODE_MESA, "eglGetModeAttribMESA"); + return EGL_FALSE; + } + + v = getModeAttrib(m, attribute); + if (v < 0) { + _eglError(EGL_BAD_ATTRIBUTE, "eglGetModeAttribMESA"); return EGL_FALSE; } + *value = v; return EGL_TRUE; } +/** + * Return human-readable string for given mode. + * This is the default function called by eglQueryModeStringMESA(). + */ const char * _eglQueryModeStringMESA(_EGLDriver *drv, EGLDisplay dpy, EGLModeMESA mode) { _EGLMode *m = _eglLookupMode(dpy, mode); + if (!m) { + _eglError(EGL_BAD_MODE_MESA, "eglQueryModeStringMESA"); + return NULL; + } return m->Name; } +#if 0 +static int +_eglRand(int max) +{ + return rand() % max; +} + +void +_eglTestModeModule(void) +{ + EGLint count = 30; + _EGLMode *modes = (_EGLMode *) malloc(count * sizeof(_EGLMode)); + _EGLMode **modeList = (_EGLMode **) malloc(count * sizeof(_EGLMode*)); + EGLint i; + + for (i = 0; i < count; i++) { + modes[i].Handle = _eglRand(20); + modes[i].Width = 512 + 256 * _eglRand(2); + modes[i].Height = 512 + 256 * _eglRand(2); + modes[i].RefreshRate = 50 + 5 * _eglRand(3); + modes[i].Interlaced = _eglRand(2); + modes[i].Optimal = _eglRand(4) == 0; + modeList[i] = modes + i; + } + + /* sort array of pointers */ + qsort(modeList, count, sizeof(_EGLMode *), compareModes); + + for (i = 0; i < count; i++) { + _EGLMode *m = modeList[i]; + printf("%2d: %3d %4d x %4d @ %3d opt %d int %d\n", i, + m->Handle, m->Width, m->Height, m->RefreshRate, + m->Optimal, m->Interlaced); + } +} +#endif diff --git a/src/egl/main/eglmode.h b/src/egl/main/eglmode.h index ed2f022d054..e70da857595 100644 --- a/src/egl/main/eglmode.h +++ b/src/egl/main/eglmode.h @@ -12,7 +12,8 @@ struct _egl_mode EGLModeMESA Handle; /* the public/opaque handle which names this mode */ EGLint Width, Height; /* size in pixels */ EGLint RefreshRate; /* rate * 1000.0 */ - EGLBoolean Stereo; + EGLint Optimal; + EGLint Interlaced; const char *Name; /* Other possible attributes */ @@ -26,8 +27,8 @@ _eglLookupMode(EGLDisplay dpy, EGLModeMESA mode); extern _EGLMode * -_eglAddMode(_EGLScreen *screen, EGLint width, EGLint height, - EGLint refreshRate, const char *name); +_eglAddNewMode(_EGLScreen *screen, EGLint width, EGLint height, + EGLint refreshRate, const char *name); extern EGLBoolean -- 2.30.2