egl_1_4/34ChooseConfig.c

   1 /*
   2  * Copyright (C) 2010 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   3  *
   4  * Contact:
   5  * DongKyun Yun <dk77.yun@samsung.com>
   6  * SangJin Kim <sangjin3.kim@samsung.com>
   7  * HyunGoo Kang <hyungoo1.kang@samsung.com>
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a copy of
  10  * this software and associated documentation files (the "Software"), to deal in
  11  * the Software without restriction, including without limitation the rights to
  12  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
  13  * of the Software, and to permit persons to whom the Software is furnished to do
  14  * so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included in all
  17  * copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  22  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  23  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  24  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  25  * SOFTWARE.
  26  *
  27  * Contributors:
  28  * - S-Core Co., Ltd
  29  *
  30  */
  31
  32 #include "implement.h"
  33
  34
  35 struct ConfigExtra configExtraDefault = {
  36         EGL_DONT_CARE, (GLXFBConfig)EGL_DONT_CARE,
  37         0, 0, 0, 0,     0, 0, 0,
  38         EGL_DONT_CARE, EGL_DONT_CARE, EGL_RGB_BUFFER, EGL_DONT_CARE,
  39         EGL_DONT_CARE, 0, 0,
  40         0, 0, 0,
  41         EGL_DONT_CARE, EGL_DONT_CARE,
  42         EGL_DONT_CARE, EGL_DONT_CARE, EGL_DONT_CARE,
  43         EGL_DONT_CARE,
  44         0, 0, 0, EGL_WINDOW_BIT,
  45         EGL_NONE, EGL_DONT_CARE, EGL_DONT_CARE, EGL_DONT_CARE,
  46 };
  47
  48 EGLBoolean EGLAPIENTRY eglChooseConfig(EGLDisplay dpy, const EGLint* attrib_list,
  49         EGLConfig* configs, EGLint config_size, EGLint* num_config) {
  50         struct DisplayExtra* pDisplay;
  51         struct ConfigExtra configValue;
  52         pDisplay = EGLINTER(LookUpDisplay)(dpy);
  53         if (pDisplay == NULL) {
  54                 EGLINTER(SetError)(EGL_BAD_DISPLAY);
  55                 return EGL_FALSE;
  56         }
  57         if (pDisplay->bInitialized == EGL_FALSE) {
  58                 EGLINTER(SetError)(EGL_NOT_INITIALIZED);
  59                 return EGL_FALSE;
  60         }
  61         if (num_config == NULL) {
  62                 EGLINTER(SetError)(EGL_BAD_PARAMETER);
  63                 return EGL_FALSE;
  64         }
  65         memcpy(&configValue, &configExtraDefault, sizeof(struct ConfigExtra));
  66         while (attrib_list && *attrib_list != EGL_NONE) {
  67                 switch (*attrib_list++) {
  68                 case EGL_CONFIG_ID:             configValue.unique = *attrib_list++; break;
  69                 case EGL_BUFFER_SIZE:   configValue.bufferSize = *attrib_list++; break;
  70                 case EGL_RED_SIZE:              configValue.redSize = *attrib_list++; break;
  71                 case EGL_GREEN_SIZE:    configValue.greenSize = *attrib_list++; break;
  72                 case EGL_BLUE_SIZE:             configValue.blueSize = *attrib_list++; break;
  73                 case EGL_LUMINANCE_SIZE:        configValue.luminanceSize = *attrib_list++; break;
  74                 case EGL_ALPHA_SIZE:            configValue.alphaSize = *attrib_list++; break;
  75                 case EGL_ALPHA_MASK_SIZE:               configValue.alphaMaskSize = *attrib_list++; break;
  76                 case EGL_BIND_TO_TEXTURE_RGB:   configValue.bindToTexRGB = *attrib_list++; break;
  77                 case EGL_BIND_TO_TEXTURE_RGBA:  configValue.bindToTexRGBA = *attrib_list++; break;
  78                 case EGL_COLOR_BUFFER_TYPE:             configValue.colorBufferType = *attrib_list++; break;
  79                 case EGL_CONFIG_CAVEAT:         configValue.configCaveat = *attrib_list++; break;
  80                 case EGL_CONFORMANT:            configValue.conformant = *attrib_list++; break;
  81                 case EGL_DEPTH_SIZE:            configValue.depthSize = *attrib_list++; break;
  82                 case EGL_LEVEL:                         configValue.level = *attrib_list++; break;
  83                 case EGL_MAX_PBUFFER_WIDTH:             attrib_list++; break;
  84                 case EGL_MAX_PBUFFER_HEIGHT:    attrib_list++; break;
  85                 case EGL_MAX_PBUFFER_PIXELS:    attrib_list++; break;
  86                 case EGL_MAX_SWAP_INTERVAL:             configValue.maxSwapInterval = *attrib_list++; break;
  87                 case EGL_MIN_SWAP_INTERVAL:             configValue.minSwapInterval = *attrib_list++; break;
  88                 case EGL_NATIVE_RENDERABLE:             configValue.nativeRenderable = *attrib_list++; break;
  89                 case EGL_NATIVE_VISUAL_ID:              attrib_list++; break;
  90                 case EGL_NATIVE_VISUAL_TYPE:    configValue.nativeVisualType = *attrib_list++; break;
  91                 case EGL_RENDERABLE_TYPE:       configValue.renderableType = *attrib_list++; break;
  92                 case EGL_SAMPLE_BUFFERS: configValue.sampleBuffers = *attrib_list++; break;
  93                 case EGL_SAMPLES: configValue.samples = *attrib_list++; break;
  94                 case EGL_STENCIL_SIZE: configValue.stencilSize = *attrib_list++; break;
  95                 case EGL_SURFACE_TYPE: configValue.surfaceType = *attrib_list++; break;
  96                 case EGL_TRANSPARENT_TYPE: configValue.transparentType = *attrib_list++; break;
  97                 case EGL_TRANSPARENT_RED_VALUE: configValue.transparentRedValue = *attrib_list++; break;
  98                 case EGL_TRANSPARENT_GREEN_VALUE: configValue.transparentGreenValue = *attrib_list++; break;
  99                 case EGL_TRANSPARENT_BLUE_VALUE: configValue.transparentBlueValue = *attrib_list++; break;
 100                 case EGL_MATCH_NATIVE_PIXMAP:   assert(0); break;
 101                 default:
 102                         EGLINTER(SetError)(EGL_BAD_ATTRIBUTE);
 103                         return EGL_FALSE;
 104                 }
 105         }
 106         struct ConfigExtra* pUnit = pDisplay->pConfigExtra;
 107         int nCount = pDisplay->nConfigExtra;
 108         int i;
 109         if (configValue.unique != EGL_DONT_CARE) {
 110                 while (nCount--) {
 111                         if (pUnit->unique == configValue.unique) {
 112                                 *num_config = 1;
 113                                 if (configs != NULL && config_size > 0) {
 114                                         configs[0] = (EGLConfig)pUnit;
 115                                 }
 116                                 return EGL_TRUE;
 117                         }
 118                         pUnit++;
 119                 }
 120                 *num_config = 0;
 121                 return EGL_TRUE;
 122         }
 123         int nAnswer = 0;
 124         EGLConfig* pAnswer = pDisplay->pConfigAnswer;
 125         for (; nCount--; pUnit++) {
 126                 if (pUnit->bufferSize < configValue.bufferSize) continue;
 127                 if (pUnit->redSize < configValue.redSize) continue;
 128                 if (pUnit->greenSize < configValue.greenSize) continue;
 129                 if (pUnit->blueSize < configValue.blueSize) continue;
 130                 if (pUnit->luminanceSize < configValue.luminanceSize) continue;
 131                 if (pUnit->alphaSize < configValue.alphaSize) continue;
 132                 if (pUnit->alphaMaskSize < configValue.alphaMaskSize) continue;
 133                 if (configValue.bindToTexRGB != EGL_DONT_CARE
 134                         && pUnit->bindToTexRGB != configValue.bindToTexRGB) continue;
 135                 if (configValue.bindToTexRGBA != EGL_DONT_CARE
 136                         && pUnit->bindToTexRGBA != configValue.bindToTexRGBA) continue;
 137                 if (pUnit->colorBufferType != configValue.colorBufferType) continue;
 138                 if (configValue.configCaveat != EGL_DONT_CARE
 139                         && pUnit->configCaveat != configValue.configCaveat) continue;
 140                 if (configValue.conformant != EGL_DONT_CARE
 141                                 && (pUnit->conformant & configValue.conformant) == 0) continue;
 142                 if (pUnit->depthSize < configValue.depthSize) continue;
 143                 if (pUnit->level != configValue.level) continue;
 144                 if (configValue.maxSwapInterval != EGL_DONT_CARE
 145                         && pUnit->maxSwapInterval != configValue.maxSwapInterval) continue;
 146                 if (configValue.minSwapInterval != EGL_DONT_CARE
 147                         && pUnit->minSwapInterval != configValue.minSwapInterval) continue;
 148                 if (configValue.nativeRenderable != EGL_DONT_CARE
 149                         && pUnit->nativeRenderable != configValue.nativeRenderable) continue;
 150                 if (configValue.renderableType != EGL_DONT_CARE
 151                                 && (pUnit->renderableType & configValue.renderableType) == 0) continue;
 152                 if (pUnit->sampleBuffers < configValue.sampleBuffers) continue;
 153                 if (pUnit->samples < configValue.samples) continue;
 154                 if (pUnit->stencilSize < configValue.stencilSize) continue;
 155                 if (pUnit->surfaceType & configValue.surfaceType == 0) continue;
 156                 if (pUnit->transparentType != configValue.transparentType) continue;
 157                 if (pUnit->transparentType != EGL_NONE
 158                         && pUnit->transparentRedValue != configValue.transparentRedValue) continue;
 159                 if (pUnit->transparentType != EGL_NONE
 160                         && pUnit->transparentGreenValue != configValue.transparentGreenValue) continue;
 161                 if (pUnit->transparentType != EGL_NONE
 162                         && pUnit->transparentBlueValue != configValue.transparentBlueValue) continue;
 163                 *pAnswer++ = pUnit;
 164                 nAnswer++;
 165         }
 166         int num = nAnswer;
 167         if (configs == NULL) {
 168                 *num_config = num;
 169         } else {
 170                 if (config_size < num) num = config_size;
 171                 if (num < 0) num = 0;
 172                 *num_config = num;
 173                 memcpy(configs, pDisplay->pConfigAnswer, num * sizeof(EGLConfig));
 174         }
 175         return EGL_TRUE;
 176 }