1 /************************************************************************** 2 * 3 * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas. 4 * Copyright 2009-2010 Chia-I Wu <olvaffe (at) gmail.com> 5 * Copyright 2010 LunarG, Inc. 6 * All Rights Reserved. 7 * 8 * Permission is hereby granted, free of charge, to any person obtaining a 9 * copy of this software and associated documentation files (the 10 * "Software"), to deal in the Software without restriction, including 11 * without limitation the rights to use, copy, modify, merge, publish, 12 * distribute, sub license, and/or sell copies of the Software, and to 13 * permit persons to whom the Software is furnished to do so, subject to 14 * the following conditions: 15 * 16 * The above copyright notice and this permission notice (including the 17 * next paragraph) shall be included in all copies or substantial portions 18 * of the Software. 19 * 20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 23 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 25 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 26 * DEALINGS IN THE SOFTWARE. 27 * 28 **************************************************************************/ 29 30 31 /** 32 * Surface-related functions. 33 */ 34 35 36 #include <assert.h> 37 #include <stdlib.h> 38 #include <string.h> 39 #include "egldisplay.h" 40 #include "eglcontext.h" 41 #include "eglconfig.h" 42 #include "eglcurrent.h" 43 #include "egllog.h" 44 #include "eglsurface.h" 45 46 47 static void 48 _eglClampSwapInterval(_EGLSurface *surf, EGLint interval) 49 { 50 EGLint bound = surf->Config->MaxSwapInterval; 51 if (interval >= bound) { 52 interval = bound; 53 } 54 else { 55 bound = surf->Config->MinSwapInterval; 56 if (interval < bound) 57 interval = bound; 58 } 59 surf->SwapInterval = interval; 60 } 61 62 63 #ifdef EGL_MESA_screen_surface 64 static EGLint 65 _eglParseScreenSurfaceAttribList(_EGLSurface *surf, const EGLint *attrib_list) 66 { 67 EGLint i, err = EGL_SUCCESS; 68 69 if (!attrib_list) 70 return EGL_SUCCESS; 71 72 for (i = 0; attrib_list[i] != EGL_NONE; i++) { 73 EGLint attr = attrib_list[i++]; 74 EGLint val = attrib_list[i]; 75 76 switch (attr) { 77 case EGL_WIDTH: 78 if (val < 0) { 79 err = EGL_BAD_PARAMETER; 80 break; 81 } 82 surf->Width = val; 83 break; 84 case EGL_HEIGHT: 85 if (val < 0) { 86 err = EGL_BAD_PARAMETER; 87 break; 88 } 89 surf->Height = val; 90 break; 91 default: 92 err = EGL_BAD_ATTRIBUTE; 93 break; 94 } 95 96 if (err != EGL_SUCCESS) { 97 _eglLog(_EGL_WARNING, "bad surface attribute 0x%04x", attr); 98 break; 99 } 100 } 101 102 return err; 103 } 104 #endif /* EGL_MESA_screen_surface */ 105 106 107 /** 108 * Parse the list of surface attributes and return the proper error code. 109 */ 110 static EGLint 111 _eglParseSurfaceAttribList(_EGLSurface *surf, const EGLint *attrib_list) 112 { 113 _EGLDisplay *dpy = surf->Resource.Display; 114 EGLint type = surf->Type; 115 EGLint texture_type = EGL_PBUFFER_BIT; 116 EGLint i, err = EGL_SUCCESS; 117 118 if (!attrib_list) 119 return EGL_SUCCESS; 120 121 #ifdef EGL_MESA_screen_surface 122 if (type == EGL_SCREEN_BIT_MESA) 123 return _eglParseScreenSurfaceAttribList(surf, attrib_list); 124 #endif 125 126 if (dpy->Extensions.NOK_texture_from_pixmap) 127 texture_type |= EGL_PIXMAP_BIT; 128 129 for (i = 0; attrib_list[i] != EGL_NONE; i++) { 130 EGLint attr = attrib_list[i++]; 131 EGLint val = attrib_list[i]; 132 133 switch (attr) { 134 /* common attributes */ 135 case EGL_VG_COLORSPACE: 136 switch (val) { 137 case EGL_VG_COLORSPACE_sRGB: 138 case EGL_VG_COLORSPACE_LINEAR: 139 break; 140 default: 141 err = EGL_BAD_ATTRIBUTE; 142 break; 143 } 144 if (err != EGL_SUCCESS) 145 break; 146 surf->VGColorspace = val; 147 break; 148 case EGL_VG_ALPHA_FORMAT: 149 switch (val) { 150 case EGL_VG_ALPHA_FORMAT_NONPRE: 151 case EGL_VG_ALPHA_FORMAT_PRE: 152 break; 153 default: 154 err = EGL_BAD_ATTRIBUTE; 155 break; 156 } 157 if (err != EGL_SUCCESS) 158 break; 159 surf->VGAlphaFormat = val; 160 break; 161 /* window surface attributes */ 162 case EGL_RENDER_BUFFER: 163 if (type != EGL_WINDOW_BIT) { 164 err = EGL_BAD_ATTRIBUTE; 165 break; 166 } 167 if (val != EGL_BACK_BUFFER && val != EGL_SINGLE_BUFFER) { 168 err = EGL_BAD_ATTRIBUTE; 169 break; 170 } 171 surf->RenderBuffer = val; 172 break; 173 case EGL_POST_SUB_BUFFER_SUPPORTED_NV: 174 if (!dpy->Extensions.NV_post_sub_buffer || 175 type != EGL_WINDOW_BIT) { 176 err = EGL_BAD_ATTRIBUTE; 177 break; 178 } 179 if (val != EGL_TRUE && val != EGL_FALSE) { 180 err = EGL_BAD_PARAMETER; 181 break; 182 } 183 surf->PostSubBufferSupportedNV = val; 184 break; 185 /* pbuffer surface attributes */ 186 case EGL_WIDTH: 187 if (type != EGL_PBUFFER_BIT) { 188 err = EGL_BAD_ATTRIBUTE; 189 break; 190 } 191 if (val < 0) { 192 err = EGL_BAD_PARAMETER; 193 break; 194 } 195 surf->Width = val; 196 break; 197 case EGL_HEIGHT: 198 if (type != EGL_PBUFFER_BIT) { 199 err = EGL_BAD_ATTRIBUTE; 200 break; 201 } 202 if (val < 0) { 203 err = EGL_BAD_PARAMETER; 204 break; 205 } 206 surf->Height = val; 207 break; 208 case EGL_LARGEST_PBUFFER: 209 if (type != EGL_PBUFFER_BIT) { 210 err = EGL_BAD_ATTRIBUTE; 211 break; 212 } 213 surf->LargestPbuffer = !!val; 214 break; 215 /* for eglBindTexImage */ 216 case EGL_TEXTURE_FORMAT: 217 if (!(type & texture_type)) { 218 err = EGL_BAD_ATTRIBUTE; 219 break; 220 } 221 switch (val) { 222 case EGL_TEXTURE_RGB: 223 case EGL_TEXTURE_RGBA: 224 case EGL_NO_TEXTURE: 225 break; 226 default: 227 err = EGL_BAD_ATTRIBUTE; 228 break; 229 } 230 if (err != EGL_SUCCESS) 231 break; 232 surf->TextureFormat = val; 233 break; 234 case EGL_TEXTURE_TARGET: 235 if (!(type & texture_type)) { 236 err = EGL_BAD_ATTRIBUTE; 237 break; 238 } 239 switch (val) { 240 case EGL_TEXTURE_2D: 241 case EGL_NO_TEXTURE: 242 break; 243 default: 244 err = EGL_BAD_ATTRIBUTE; 245 break; 246 } 247 if (err != EGL_SUCCESS) 248 break; 249 surf->TextureTarget = val; 250 break; 251 case EGL_MIPMAP_TEXTURE: 252 if (!(type & texture_type)) { 253 err = EGL_BAD_ATTRIBUTE; 254 break; 255 } 256 surf->MipmapTexture = !!val; 257 break; 258 /* no pixmap surface specific attributes */ 259 default: 260 err = EGL_BAD_ATTRIBUTE; 261 break; 262 } 263 264 if (err != EGL_SUCCESS) { 265 _eglLog(_EGL_WARNING, "bad surface attribute 0x%04x", attr); 266 break; 267 } 268 } 269 270 return err; 271 } 272 273 274 /** 275 * Do error check on parameters and initialize the given _EGLSurface object. 276 * \return EGL_TRUE if no errors, EGL_FALSE otherwise. 277 */ 278 EGLBoolean 279 _eglInitSurface(_EGLSurface *surf, _EGLDisplay *dpy, EGLint type, 280 _EGLConfig *conf, const EGLint *attrib_list) 281 { 282 const char *func; 283 EGLint renderBuffer = EGL_BACK_BUFFER; 284 EGLint swapBehavior = EGL_BUFFER_PRESERVED; 285 EGLint err; 286 287 switch (type) { 288 case EGL_WINDOW_BIT: 289 func = "eglCreateWindowSurface"; 290 swapBehavior = EGL_BUFFER_DESTROYED; 291 break; 292 case EGL_PIXMAP_BIT: 293 func = "eglCreatePixmapSurface"; 294 renderBuffer = EGL_SINGLE_BUFFER; 295 break; 296 case EGL_PBUFFER_BIT: 297 func = "eglCreatePBufferSurface"; 298 break; 299 #ifdef EGL_MESA_screen_surface 300 case EGL_SCREEN_BIT_MESA: 301 func = "eglCreateScreenSurface"; 302 renderBuffer = EGL_SINGLE_BUFFER; /* XXX correct? */ 303 break; 304 #endif 305 default: 306 _eglLog(_EGL_WARNING, "Bad type in _eglInitSurface"); 307 return EGL_FALSE; 308 } 309 310 if ((conf->SurfaceType & type) == 0) { 311 /* The config can't be used to create a surface of this type */ 312 _eglError(EGL_BAD_CONFIG, func); 313 return EGL_FALSE; 314 } 315 316 _eglInitResource(&surf->Resource, sizeof(*surf), dpy); 317 surf->Type = type; 318 surf->Config = conf; 319 320 surf->Width = 0; 321 surf->Height = 0; 322 surf->TextureFormat = EGL_NO_TEXTURE; 323 surf->TextureTarget = EGL_NO_TEXTURE; 324 surf->MipmapTexture = EGL_FALSE; 325 surf->LargestPbuffer = EGL_FALSE; 326 surf->RenderBuffer = renderBuffer; 327 surf->VGAlphaFormat = EGL_VG_ALPHA_FORMAT_NONPRE; 328 surf->VGColorspace = EGL_VG_COLORSPACE_sRGB; 329 330 surf->MipmapLevel = 0; 331 surf->MultisampleResolve = EGL_MULTISAMPLE_RESOLVE_DEFAULT; 332 surf->SwapBehavior = swapBehavior; 333 334 surf->HorizontalResolution = EGL_UNKNOWN; 335 surf->VerticalResolution = EGL_UNKNOWN; 336 surf->AspectRatio = EGL_UNKNOWN; 337 338 surf->PostSubBufferSupportedNV = EGL_FALSE; 339 340 /* the default swap interval is 1 */ 341 _eglClampSwapInterval(surf, 1); 342 343 err = _eglParseSurfaceAttribList(surf, attrib_list); 344 if (err != EGL_SUCCESS) 345 return _eglError(err, func); 346 347 return EGL_TRUE; 348 } 349 350 351 EGLBoolean 352 _eglQuerySurface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface, 353 EGLint attribute, EGLint *value) 354 { 355 switch (attribute) { 356 case EGL_WIDTH: 357 *value = surface->Width; 358 break; 359 case EGL_HEIGHT: 360 *value = surface->Height; 361 break; 362 case EGL_CONFIG_ID: 363 *value = surface->Config->ConfigID; 364 break; 365 case EGL_LARGEST_PBUFFER: 366 *value = surface->LargestPbuffer; 367 break; 368 case EGL_TEXTURE_FORMAT: 369 /* texture attributes: only for pbuffers, no error otherwise */ 370 if (surface->Type == EGL_PBUFFER_BIT) 371 *value = surface->TextureFormat; 372 break; 373 case EGL_TEXTURE_TARGET: 374 if (surface->Type == EGL_PBUFFER_BIT) 375 *value = surface->TextureTarget; 376 break; 377 case EGL_MIPMAP_TEXTURE: 378 if (surface->Type == EGL_PBUFFER_BIT) 379 *value = surface->MipmapTexture; 380 break; 381 case EGL_MIPMAP_LEVEL: 382 if (surface->Type == EGL_PBUFFER_BIT) 383 *value = surface->MipmapLevel; 384 break; 385 case EGL_SWAP_BEHAVIOR: 386 *value = surface->SwapBehavior; 387 break; 388 case EGL_RENDER_BUFFER: 389 *value = surface->RenderBuffer; 390 break; 391 case EGL_PIXEL_ASPECT_RATIO: 392 *value = surface->AspectRatio; 393 break; 394 case EGL_HORIZONTAL_RESOLUTION: 395 *value = surface->HorizontalResolution; 396 break; 397 case EGL_VERTICAL_RESOLUTION: 398 *value = surface->VerticalResolution; 399 break; 400 case EGL_MULTISAMPLE_RESOLVE: 401 *value = surface->MultisampleResolve; 402 break; 403 case EGL_VG_ALPHA_FORMAT: 404 *value = surface->VGAlphaFormat; 405 break; 406 case EGL_VG_COLORSPACE: 407 *value = surface->VGColorspace; 408 break; 409 case EGL_POST_SUB_BUFFER_SUPPORTED_NV: 410 *value = surface->PostSubBufferSupportedNV; 411 break; 412 default: 413 _eglError(EGL_BAD_ATTRIBUTE, "eglQuerySurface"); 414 return EGL_FALSE; 415 } 416 417 return EGL_TRUE; 418 } 419 420 421 /** 422 * Default fallback routine - drivers might override this. 423 */ 424 EGLBoolean 425 _eglSurfaceAttrib(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface, 426 EGLint attribute, EGLint value) 427 { 428 EGLint confval; 429 EGLint err = EGL_SUCCESS; 430 431 switch (attribute) { 432 case EGL_MIPMAP_LEVEL: 433 confval = surface->Config->RenderableType; 434 if (!(confval & (EGL_OPENGL_ES_BIT | EGL_OPENGL_ES2_BIT))) { 435 err = EGL_BAD_PARAMETER; 436 break; 437 } 438 surface->MipmapLevel = value; 439 break; 440 case EGL_MULTISAMPLE_RESOLVE: 441 switch (value) { 442 case EGL_MULTISAMPLE_RESOLVE_DEFAULT: 443 break; 444 case EGL_MULTISAMPLE_RESOLVE_BOX: 445 confval = surface->Config->SurfaceType; 446 if (!(confval & EGL_MULTISAMPLE_RESOLVE_BOX_BIT)) 447 err = EGL_BAD_MATCH; 448 break; 449 default: 450 err = EGL_BAD_ATTRIBUTE; 451 break; 452 } 453 if (err != EGL_SUCCESS) 454 break; 455 surface->MultisampleResolve = value; 456 break; 457 case EGL_SWAP_BEHAVIOR: 458 switch (value) { 459 case EGL_BUFFER_DESTROYED: 460 break; 461 case EGL_BUFFER_PRESERVED: 462 confval = surface->Config->SurfaceType; 463 if (!(confval & EGL_SWAP_BEHAVIOR_PRESERVED_BIT)) 464 err = EGL_BAD_MATCH; 465 break; 466 default: 467 err = EGL_BAD_ATTRIBUTE; 468 break; 469 } 470 if (err != EGL_SUCCESS) 471 break; 472 surface->SwapBehavior = value; 473 break; 474 default: 475 err = EGL_BAD_ATTRIBUTE; 476 break; 477 } 478 479 if (err != EGL_SUCCESS) 480 return _eglError(err, "eglSurfaceAttrib"); 481 return EGL_TRUE; 482 } 483 484 485 EGLBoolean 486 _eglBindTexImage(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface, 487 EGLint buffer) 488 { 489 EGLint texture_type = EGL_PBUFFER_BIT; 490 491 /* Just do basic error checking and return success/fail. 492 * Drivers must implement the real stuff. 493 */ 494 495 if (dpy->Extensions.NOK_texture_from_pixmap) 496 texture_type |= EGL_PIXMAP_BIT; 497 498 if (!(surface->Type & texture_type)) { 499 _eglError(EGL_BAD_SURFACE, "eglBindTexImage"); 500 return EGL_FALSE; 501 } 502 503 if (surface->TextureFormat == EGL_NO_TEXTURE) { 504 _eglError(EGL_BAD_MATCH, "eglBindTexImage"); 505 return EGL_FALSE; 506 } 507 508 if (surface->TextureTarget == EGL_NO_TEXTURE) { 509 _eglError(EGL_BAD_MATCH, "eglBindTexImage"); 510 return EGL_FALSE; 511 } 512 513 if (buffer != EGL_BACK_BUFFER) { 514 _eglError(EGL_BAD_PARAMETER, "eglBindTexImage"); 515 return EGL_FALSE; 516 } 517 518 surface->BoundToTexture = EGL_TRUE; 519 520 return EGL_TRUE; 521 } 522 523 524 EGLBoolean 525 _eglSwapInterval(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf, 526 EGLint interval) 527 { 528 _eglClampSwapInterval(surf, interval); 529 return EGL_TRUE; 530 } 531
