src/gpu/cairo-gpu-impl-space-gl.h

   1 #include <dlfcn.h>
   2
   3 typedef struct
   4 {
   5         cairo_gpu_gl_state_t user;
   6         cairo_gpu_context_t* ctx;
   7         int depth;
   8 } cairo_gpu_gl_tls_t;
   9
  10 __thread cairo_gpu_gl_tls_t _cairo_gl_tls;
  11
  12 static cairo_gpu_context_t*
  13 _cairo_gpu_context__create(cairo_gpu_space_t *space, cairo_gpu_subspace_t *sub)
  14 {
  15         cairo_gpu_context_t* ctx = calloc(1, sizeof(cairo_gpu_context_t));
  16
  17         ctx->space = space;
  18         ctx->subspace = sub;
  19
  20         ctx->color_mask = 0xf;
  21         ctx->blend_func = ~0;
  22         ctx->frag = ~0;
  23         ctx->vert = 0;
  24         ctx->fragp = ~0;
  25         ctx->vertp = ~0;
  26         ctx->constant_unit = -1;
  27         ctx->viewport_width = -1;
  28         ctx->viewport_height = -1;
  29         return ctx;
  30 }
  31
  32 static cairo_bool_t
  33 _cairo_gpu_hash_keys_equal(const void *key_a, const void *key_b)
  34 {
  35         return ((cairo_hash_entry_t*)key_a)->hash == ((cairo_hash_entry_t*)key_b)->hash;
  36 }
  37
  38 static cairo_gpu_space_t *
  39 _cairo_gpu_space__begin_create(void)
  40 {
  41         cairo_gpu_space_t *space;
  42
  43         space = calloc(1, sizeof(cairo_gpu_space_t));
  44         if(!space)
  45                 return 0;
  46
  47         CAIRO_REFERENCE_COUNT_INIT(&space->base.ref_count, 1);
  48         CAIRO_MUTEX_INIT(space->mutex);
  49         CAIRO_MUTEX_INIT(space->cached_mask_surface_mutex);
  50         space->base.backend = &_cairo_gpu_space_backend;
  51         space->tls_list.prev = &space->tls_list;
  52         space->tls_list.next = &space->tls_list;
  53         pthread_key_create(&space->tls, _cairo_gpu_space_tls_dtor);
  54         pthread_key_create(&space->subspace.context_tls, 0);
  55         space->table = _cairo_hash_table_create(_cairo_gpu_hash_keys_equal);
  56
  57         return space;
  58 }
  59
  60 static cairo_space_t*
  61 _cairo_gpu_space__finish_create(cairo_gpu_space_t* space, unsigned flags);
  62
  63 #include "cairo-gpu-impl-space-gl-osmesa.h"
  64 #include "cairo-gpu-impl-space-gl-glx.h"
  65
  66 static inline unsigned
  67 _cairo_gl_error(cairo_gpu_context_t* ctx)
  68 {
  69         unsigned err;
  70         if((err = ctx->gl.GetError()))
  71         {
  72                 while(ctx->gl.GetError())
  73                 {}
  74         }
  75         return err;
  76 }
  77
  78 static inline void
  79 _cairo_gpu_assert_no_gl_error(cairo_gpu_context_t* ctx)
  80 {
  81         static int errors = 0;
  82         unsigned err;
  83         while((err = ctx->gl.GetError()))
  84         {
  85                 // race condition here but we don't really care
  86                 int n = errors;
  87                 if(n == 10)
  88                 {
  89                         printf("WARNING: cairo-gpu: not showing any more OpenGL errors\n");
  90                         errors = n +1;
  91                 }
  92                 else if(n < 10)
  93                 {
  94                         printf("WARNING: cairo-gpu: unexpected OpenGL error: %x\n", err);
  95                         errors = n + 1;
  96                 }
  97         }
  98 }
  99
 100 #define GL_ERROR(x) (_cairo_gpu_assert_no_gl_error(ctx), x, _cairo_gl_error(ctx))
 101
 102 static void
 103 _cairo_gpu_gl_init(cairo_gpu_gl_t* gl, PFNGLGETPROCADDRESSPROC GetProcAddress)
 104 {
 105 #define DO(x) gl->x = GetProcAddress("gl" #x)
 106         DO(ActiveTextureARB);
 107         DO(BindBufferARB);
 108         DO(BindFramebufferEXT);
 109         DO(BindProgramARB);
 110         DO(BindRenderbufferEXT);
 111         DO(BindTextureEXT);
 112         DO(BindVertexArray);
 113         DO(BlendColorEXT);
 114         DO(BlendEquation);
 115         DO(BlendFunc);
 116         DO(BlendFuncSeparateEXT);
 117         DO(BlitFramebufferEXT);
 118         DO(BufferDataARB);
 119         DO(CheckFramebufferStatusEXT);
 120         DO(Clear);
 121         DO(ClearColor);
 122         DO(ClientActiveTextureARB);
 123         DO(Color4fv);
 124         DO(ColorMask);
 125         DO(ColorPointer);
 126         DO(CopyPixels);
 127         DO(CopyTexSubImage2D);
 128         DO(DeleteBuffersARB);
 129         DO(DeleteFramebuffersEXT);
 130         DO(DeleteProgramsARB);
 131         DO(DeleteRenderbuffersEXT);
 132         DO(DeleteTexturesEXT);
 133         DO(DeleteVertexArrays);
 134         DO(Disable);
 135         DO(DisableClientState);
 136         DO(DrawArraysEXT);
 137         DO(DrawBuffer);
 138         DO(DrawPixels);
 139         DO(Enable);
 140         DO(EnableClientState);
 141         DO(EnableVertexAttribArrayARB);
 142         DO(Finish);
 143         DO(Flush);
 144         DO(FramebufferRenderbufferEXT);
 145         DO(FramebufferTexture2DEXT);
 146         DO(GenBuffersARB);
 147         DO(GenerateMipmapEXT);
 148         DO(GenFramebuffersEXT);
 149         DO(GenProgramsARB);
 150         DO(GenRenderbuffersEXT);
 151         DO(GenTexturesEXT);
 152         DO(GenVertexArrays);
 153         DO(GetError);
 154         DO(GetFloatv);
 155         DO(GetIntegerv);
 156         DO(GetString);
 157         DO(GetTexImage);
 158         DO(Hint);
 159         DO(LoadIdentity);
 160         DO(LoadMatrixd);
 161         DO(LoadMatrixf);
 162         DO(MapBufferARB);
 163         DO(MapBufferRange);
 164         DO(MatrixMode);
 165         DO(Ortho);
 166         DO(PixelMapfv);
 167         DO(PixelStorei);
 168         DO(PixelTransferf);
 169         DO(PixelZoom);
 170         DO(ProgramEnvParameter4fvARB);
 171         DO(ProgramStringARB);
 172         DO(RasterPos2i);
 173         DO(ReadBuffer);
 174         DO(ReadPixels);
 175         DO(Recti);
 176         DO(RenderbufferStorageMultisampleCoverageNV);
 177         DO(RenderbufferStorageMultisampleEXT);
 178         DO(Scissor);
 179         DO(TexCoordPointer);
 180         DO(TexEnvfv);
 181         DO(TexEnvi);
 182         DO(TexGenfv);
 183         DO(TexGeni);
 184         DO(TexImage2D);
 185         DO(TexParameteri);
 186         DO(TexSubImage2D);
 187         DO(Translated);
 188         DO(Translatef);
 189         DO(UnmapBufferARB);
 190         DO(VertexPointer);
 191         DO(Viewport);
 192         DO(WindowPos2i);
 193 #undef DO
 194 }
 195
 196 static void
 197 _cairo_gpu_space__fini_entry(void* abstract_entry, void* closure)
 198 {
 199         cairo_gpu_context_t* ctx = closure;
 200         cairo_gpu_int_entry_t* int_entry = (cairo_gpu_int_entry_t*)abstract_entry;
 201         //cairo_gpu_ptr_entry* ptr_entry = (cairo_gpu_ptr_entry_t*)abstract_entry;
 202         switch(int_entry->base.hash & TABLE_MASK)
 203         {
 204         case TABLE_FRAG:
 205         case TABLE_VERT:
 206                 ctx->gl.DeleteProgramsARB(1, &int_entry->v);
 207                 break;
 208         default:
 209                 break;
 210         }
 211
 212         _cairo_hash_table_remove(ctx->space->table, (cairo_hash_entry_t*)abstract_entry);
 213         free(abstract_entry);
 214 }
 215
 216 static void
 217 _cairo_gpu_space__fini(cairo_gpu_context_t * ctx)
 218 {
 219         cairo_gpu_space_t* space = ctx->space;
 220
 221         _cairo_gpu_texture_fini(ctx, &space->dummy_texture);
 222
 223         _cairo_hash_table_foreach (space->table, _cairo_gpu_space__fini_entry, ctx);
 224         _cairo_hash_table_destroy(space->table);
 225 }
 226
 227 // ctx == 0, user.api < 0 => we have an user context bound, or nothing
 228 // ctx != 0, user.api < 0 => we have either an user context bound, or nothing, or ctx
 229 // ctx != 0, user_api >= 0 => we have ctx bound, and may have an user context saved
 230 // ctx == 0, user.api > 0 => we have an user context bound, and we have an user context saved
 231 // ctx == 0, user.api == 0 => we have no context bound, and we have no user context saved
 232
 233 static inline void
 234 _cairo_gpu_enter(void)
 235 {
 236         ++_cairo_gl_tls.depth;
 237 }
 238
 239 static inline void
 240 _cairo_gl_make_current(cairo_gpu_space_t* space, cairo_gpu_gl_state_t* user)
 241 {
 242         API_SPACE(make_current)(space, user);
 243 }
 244
 245 static void
 246 _cairo_gpu_space__do_destroy(cairo_gpu_space_t* space)
 247 {
 248         API_SPACE(do_destroy)(space);
 249
 250         if(space->owns_libgl)
 251                 dlclose(space->libgl);
 252         free(space);
 253 }
 254
 255 static void
 256 _cairo_gpu_context__do_destroy(cairo_gpu_context_t * ctx)
 257 {
 258         cairo_gpu_space_t* space = ctx->space;
 259
 260         API_CTX(do_destroy)(ctx);
 261
 262         free(ctx);
 263
 264         if(space->destroy_on_unbind)
 265                 _cairo_gpu_space__do_destroy(space);
 266 }
 267
 268 static cairo_gpu_context_t*
 269 _cairo_gpu_context__unbind_internal(void)
 270 {
 271         cairo_gpu_context_t* ctx = _cairo_gl_tls.ctx;
 272         API_CTX(flush)(ctx);
 273
 274         _cairo_gpu_assert_no_gl_error(ctx);
 275
 276         if(ctx->destroy_on_unbind)
 277                 return ctx;
 278
 279         return 0;
 280 }
 281
 282 static void
 283 _cairo_gpu_do_exit(void)
 284 {
 285         cairo_gpu_context_t* ctx = _cairo_gl_tls.ctx;
 286         cairo_gpu_context_t* destroy_ctx = 0;
 287         if(ctx)
 288         {
 289                 destroy_ctx = _cairo_gpu_context__unbind_internal();
 290
 291                 if(destroy_ctx && !_cairo_gl_tls.user.api)
 292                 {
 293                         cairo_gpu_space_t* space = ctx->space;
 294                         API_SPACE(unbind_context)(space);
 295
 296                         _cairo_gl_tls.ctx = 0;
 297                 }
 298         }
 299
 300         if(_cairo_gl_tls.user.api)
 301         {
 302                 _cairo_gl_make_current(ctx->space, &_cairo_gl_tls.user);
 303                 _cairo_gl_tls.user.api = 0;
 304                 _cairo_gl_tls.ctx = 0;
 305         }
 306
 307         _cairo_gl_tls.user.api = -1;
 308
 309         if(destroy_ctx)
 310                 _cairo_gpu_context__do_destroy(destroy_ctx);
 311 }
 312
 313 /*
 314  * NOTE: if no OpenGL context was set, we leak our current context.
 315  * This allows to run many Cairo commands without rebinding the context every time.
 316  * The risk is that the user may accidentally mess up our GL context.
 317  */
 318 static inline void
 319 _cairo_gpu_exit(void)
 320 {
 321         if(!--_cairo_gl_tls.depth && _cairo_gl_tls.user.api >= 0)
 322                 _cairo_gpu_do_exit();
 323 }
 324
 325 // you must bind a context after calling this
 326 static void
 327 _cairo_gpu_context__update_state(cairo_gpu_context_t* ctx, unsigned api)
 328 {
 329         cairo_gpu_gl_state_t* user = &_cairo_gl_tls.user;
 330         user->api = 0;
 331         API_CTX(update_state)(ctx, user);
 332 }
 333
 334 static void
 335 _cairo_gpu_context__do_bind(cairo_gpu_context_t* ctx, cairo_gpu_surface_t * surface)
 336 {
 337         cairo_gpu_context_t* destroy_ctx = 0;
 338         if(_cairo_gl_tls.ctx)
 339                 destroy_ctx = _cairo_gpu_context__unbind_internal();
 340
 341         API_CTX(do_bind)(ctx, surface);
 342
 343         if(!ctx->gl_inited)
 344         {
 345                 _cairo_gpu_gl_init(&ctx->gl, ctx->space->GetProcAddress);
 346                 ctx->gl_inited = 1;
 347         }
 348         _cairo_gl_tls.ctx = ctx;
 349
 350         if(destroy_ctx)
 351                 _cairo_gpu_context__do_destroy(destroy_ctx);
 352 }
 353
 354 static inline void
 355 _cairo_gl_context_bind_surface(cairo_gpu_context_t* ctx, cairo_gpu_surface_t * surface)
 356 {
 357          assert(_cairo_gl_tls.depth);
 358
 359         if(_cairo_gl_tls.user.api < 0)
 360                 _cairo_gpu_context__update_state(ctx, ctx->space->api);
 361
 362         if(_cairo_gl_tls.ctx == ctx)
 363         {
 364                 if(surface && surface->has_drawable)
 365                 {
 366                 // lenient one-way version
 367                         if(!API_CTX(is_surface_bound)(ctx, surface))
 368                                 goto bind;
 369                 }
 370         }
 371         else
 372         {
 373 bind:
 374                 _cairo_gpu_context__do_bind(ctx, surface);
 375         }
 376 }
 377
 378 static inline void
 379 _cairo_gpu_context_bind(cairo_gpu_context_t* ctx)
 380 {
 381         assert(_cairo_gl_tls.depth);
 382
 383         if(_cairo_gl_tls.user.api < 0)
 384                 _cairo_gpu_context__update_state(ctx, ctx->space->api);
 385
 386         if(_cairo_gl_tls.ctx == ctx)
 387                 return;
 388         else
 389                 _cairo_gpu_context__do_bind(ctx, 0);
 390 }
 391
 392 static void
 393 _cairo_gpu_context__destroy(cairo_gpu_context_t * ctx)
 394 {
 395         assert(_cairo_gl_tls.depth);
 396
 397         if(_cairo_gl_tls.user.api < 0)
 398                 _cairo_gpu_context__update_state(ctx, ctx->space->api);
 399
 400         if(ctx == _cairo_gl_tls.ctx)
 401         {
 402                 ctx->destroy_on_unbind = 1;
 403                 return;
 404         }
 405
 406         _cairo_gpu_context__do_destroy(ctx);
 407 }
 408
 409 cairo_public cairo_space_t *
 410 cairo_gl_hardware_space_create(void* libgl, unsigned flags)
 411 {
 412         cairo_space_t *space;
 413
 414         space = cairo_glx_space_create(libgl, 0, 1, 0, flags);
 415         if(space)
 416         {
 417                 if(space->is_software)
 418                         cairo_space_destroy(space);
 419                 else
 420                         return space;
 421         }
 422
 423         return 0;
 424 }
 425
 426 cairo_public cairo_space_t *
 427 cairo_gl_space_create(void* libgl, unsigned flags)
 428 {
 429         cairo_space_t *space;
 430
 431         space = cairo_glx_space_create(libgl, 0, 1, 0, flags);
 432         if(space)
 433                 return space;
 434
 435         space = cairo_osmesa_space_create(libgl, 0, flags);
 436         if(space)
 437                 return space;
 438
 439         return 0;
 440 }
 441
 442 static inline cairo_gpu_space_tls_t*
 443 _cairo_gpu_space_alloc_tls(cairo_gpu_space_t* space)
 444 {
 445         return (cairo_gpu_space_tls_t*)calloc(sizeof(cairo_gpu_space_tls_t), 1);
 446 }
 447
 448 static cairo_font_options_t *
 449 _cairo_gpu_get_font_options (cairo_gpu_space_t* space)
 450 {
 451     if (space->has_font_options)
 452         return &space->font_options;
 453
 454     CAIRO_MUTEX_LOCK(space->mutex);
 455     if (! space->has_font_options) {
 456         _cairo_font_options_init_default (&space->font_options);
 457
 458         space->font_options.antialias = CAIRO_ANTIALIAS_SUBPIXEL;
 459
 460         API_SPACE(init_font_options)(space);
 461
 462         space->has_font_options = TRUE;
 463     }
 464     CAIRO_MUTEX_UNLOCK(space->mutex);
 465
 466     return &space->font_options;
 467 }
 468
 469 static void
 470 _cairo_gpu_set_surface_subspace(cairo_gpu_surface_t* surface)
 471 {
 472         cairo_gpu_space_t* space = surface->space;
 473         API_SPACE(set_surface_subspace)(space, surface);
 474 }
 475
 476 static cairo_gpu_context_t *
 477 _cairo_gpu_space_tls__create_context(cairo_gpu_space_tls_t* tls, cairo_gpu_subspace_t* sub)
 478 {
 479         cairo_gpu_space_t* space = tls->space;
 480         cairo_gpu_context_t* ctx;
 481
 482         if(!sub)
 483         {
 484                 // use the last subspace so that we hopefully minimize the number of created context
 485                 sub = &space->subspace;
 486                 while(sub->next)
 487                         sub = sub->next;
 488         }
 489
 490         ctx = API_SPACE(create_context)(space, sub);
 491
 492         ctx->tls = tls;
 493         ctx->next = tls->contexts;
 494         tls->contexts = ctx;
 495
 496         pthread_setspecific(sub->context_tls, ctx);
 497         tls->last_context = ctx;
 498         return ctx;
 499 }
 500
 501 static inline void
 502 _cairo_gpu_space_tls_destroy_contexts(cairo_gpu_space_tls_t* tls)
 503 {
 504         cairo_gpu_context_t* ctx;
 505         cairo_gpu_context_t* ctx_next;
 506         for(ctx = tls->contexts; ctx; ctx = ctx_next)
 507         {
 508                 ctx_next = ctx->next;
 509
 510                 _cairo_gpu_context__destroy(ctx);
 511         }
 512 }
 513
 514 static inline cairo_gpu_context_t *
 515 _cairo_gpu_space_tls_lookup_context(cairo_gpu_space_tls_t* tls)
 516 {
 517         cairo_gpu_context_t* ctx = 0;
 518
 519         ctx = tls->last_context;
 520
 521         if(!ctx)
 522                 ctx = _cairo_gpu_space_tls__create_context(tls, 0);
 523         return ctx;
 524 }
 525
 526 static void
 527 _cairo_gpu_space__destroy(cairo_gpu_space_t * space)
 528 {
 529         cairo_gpu_subspace_t * sub;
 530         cairo_gpu_subspace_t * sub_next;
 531         cairo_gpu_space_tls_t* tls;
 532         cairo_gpu_space_tls_t* tls_next;
 533
 534         pthread_key_delete(space->tls);
 535
 536         {
 537                 cairo_gpu_context_t* ctx = _cairo_gpu_space_bind(space);
 538                 _cairo_gpu_space__fini(ctx);
 539         }
 540
 541         pthread_key_delete(space->subspace.context_tls);
 542
 543         for(tls = (cairo_gpu_space_tls_t*)space->tls_list.next; (list_node_t*)tls != &space->tls_list; tls = tls_next)
 544         {
 545                 tls_next = (cairo_gpu_space_tls_t*)tls->node.next;
 546
 547                 _cairo_gpu_space_tls_destroy(tls);
 548         }
 549
 550         for(sub = space->subspace.next; sub; sub = sub_next)
 551         {
 552                 sub_next = sub->next;
 553
 554                 pthread_key_delete(sub->context_tls);
 555
 556                 API_SPACE(destroy_subspace)(space, sub);
 557
 558                 free(sub);
 559         }
 560
 561         space->destroy_on_unbind = 1;
 562 }
 563
 564 static void
 565 _cairo_gpu_space_destroy(void* abstract_space)
 566 {
 567         cairo_gpu_space_t * space = abstract_space;
 568
 569         _cairo_gpu_enter();
 570         _cairo_gpu_space__destroy(space);
 571         _cairo_gpu_exit();
 572 }
 573
 574 /* only current thread */
 575 static cairo_status_t
 576 _cairo_gpu_space_sync(void* abstract_space)
 577 {
 578         cairo_gpu_space_t* space = abstract_space;
 579         cairo_gpu_space_tls_t* tls = (cairo_gpu_space_tls_t*)_cairo_gpu_space_get_tls(space);
 580         cairo_gpu_context_t* ctx;
 581
 582         _cairo_gpu_enter();
 583         for(ctx = tls->contexts; ctx; ctx = ctx->next)
 584         {
 585                 _cairo_gpu_context_bind(ctx);
 586                 ctx->gl.Finish();
 587         }
 588         _cairo_gpu_exit();
 589         return CAIRO_STATUS_SUCCESS;
 590 }
 591
 592 static int
 593 _cairo_gpu_space__init(cairo_gpu_context_t *ctx, unsigned flags)
 594 {
 595         cairo_gpu_space_t* space = ctx->space;
 596         char *vendor;
 597         char *renderer;
 598         char* extensions;
 599         unsigned dummy_tex_data = 0;
 600
 601         // TODO: this assumes that GL extensions don't change between context
 602         extensions = (char *)ctx->gl.GetString(GL_EXTENSIONS);
 603         vendor = (char *)ctx->gl.GetString(GL_VENDOR);
 604         renderer = (char *)ctx->gl.GetString(GL_RENDERER);
 605
 606         // TODO: any better solutions?
 607         space->base.is_software = strstr(renderer, "software") || strstr(renderer, "Software");
 608
 609         // these can be implemented on any hardware
 610         if(!strstr(extensions, "EXT_texture_object") || !strstr(extensions, "EXT_vertex_array"))
 611         {
 612                 fprintf(stderr, "ERROR: the current OpenGL driver is severely deficient: it is missing EXT_texture_object or EXT_vertex_array!\n");
 613                 goto fail;
 614         }
 615
 616         space->tex_units = 1;
 617         if(!!strstr(extensions, "ARB_multitexture"))
 618         {
 619                 int tex_units;
 620                 int limit;
 621                 ctx->gl.GetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &tex_units);
 622
 623                 // 4 is enough for us
 624                 limit = 4 - ((flags >> CAIRO_GPU_GL_FORCE_TEX_UNITS_SHIFT) & 3);
 625
 626                 if(tex_units > limit)
 627                         tex_units = limit;
 628                 space->tex_units = tex_units;
 629         }
 630
 631         space->use_fbo = !(flags & CAIRO_GPU_GL_DISABLE_FRAMEBUFFER_OBJECT) && strstr(extensions, "EXT_framebuffer_object");
 632
 633         if(!space->use_fbo)
 634         {
 635                 if(!API_SPACE(has_offscreen_drawables)(space))
 636                         goto fail;
 637         }
 638
 639         space->fb_blit = !(flags & CAIRO_GPU_GL_DISABLE_FRAMEBUFFER_BLIT) && strstr(extensions, "EXT_framebuffer_blit");
 640
 641         ctx->space->use_vbo = !!strstr(extensions, "EXT_vertex_buffer_object");
 642
 643         if(!(flags & CAIRO_GPU_GL_DISABLE_TEXTURE_NON_POWER_OF_TWO) &&
 644                         strstr(extensions, "ARB_texture_non_power_of_two"))
 645                 space->tex_npot = 1;
 646
 647         if(!(flags & CAIRO_GPU_GL_DISABLE_TEXTURE_RECTANGLE)
 648                         && (strstr(extensions, "ARB_texture_rectangle") || strstr(extensions, "EXT_texture_rectangle") || strstr(extensions, "NV_texture_rectangle")))
 649                 space->tex_rectangle = 1;
 650
 651         space->extend_mask = 1 << CAIRO_EXTEND_REPEAT;
 652
 653         /* These are pretty much guaranteed */
 654         if(strstr(extensions, "ARB_texture_border_clamp") || strstr(extensions, "SGIS_texture_border_clamp"))
 655                 space->extend_mask |= 1 << CAIRO_EXTEND_NONE;
 656
 657         if(strstr(extensions, "EXT_texture_edge_clamp") || strstr(extensions, "SGIS_texture_edge_clamp"))
 658                 space->extend_mask |= 1 << CAIRO_EXTEND_PAD;
 659
 660         if(strstr(extensions, "ARB_texture_mirrored_repeat"))
 661                 space->extend_mask |= 1 << CAIRO_EXTEND_REFLECT;
 662
 663         space->use_vert_prog = !(flags & CAIRO_GPU_GL_DISABLE_VERTEX_PROGRAM) && strstr(extensions, "ARB_vertex_program");
 664
 665         space->vert_op = space->vert_passthru = space->use_vert_prog;
 666
 667         space->use_frag_prog = !(flags & CAIRO_GPU_GL_DISABLE_FRAGMENT_PROGRAM) && strstr(extensions, "ARB_fragment_program");
 668
 669         space->has_combine = !(flags & CAIRO_GPU_GL_DISABLE_TEX_ENV_COMBINE) && !!strstr(extensions, "ARB_texture_env_combine");
 670
 671         space->use_intensity = !space->use_frag_prog && !space->has_combine;
 672
 673         // we do this because we need GL_INTENSITY textures for GL_MODULATE, that wouldn't be renderable and in addition hardware/drivers without ARB_texture_env_combine are less likely to support FBOs
 674         // TODO: don't do this, but add new SURF_ALPHA / SURF_INTENSITY texture "aliases"
 675         if(!space->use_frag_prog && !space->has_combine)
 676                 space->use_fbo = 0;
 677
 678         space->crossbar = strstr(extensions, "ARB_texture_env_crossbar") || strstr(extensions, "NV_texture_env_combine4");
 679
 680         space->per_component = (space->use_frag_prog || (space->has_combine && space->crossbar && strstr(extensions, "ARB_texture_env_dot3")));
 681         space->radial = space->frag_div_alpha = space->discontinuous = space->use_frag_prog;
 682         space->tex_aaaa_111a = space->frag_mul_alpha = space->use_frag_prog || space->has_combine;
 683
 684         space->frag_passthru = space->use_frag_prog || strstr(extensions, "NV_texture_shader");
 685
 686         space->blend_func_separate = !(flags & CAIRO_GPU_GL_DISABLE_BLEND_FUNC_SEPARATE) && strstr(extensions, "EXT_blend_func_separate");
 687         space->blend_color = !!strstr(extensions, "EXT_blend_color");
 688         space->blend_subtract = !!strstr(extensions, "EXT_blend_subtract"),
 689         space->has_window_pos = !!strstr(extensions, "ARB_window_pos");
 690         space->has_framebuffer_multisample = !!strstr(extensions, "EXT_framebuffer_multisample");
 691         space->has_framebuffer_multisample_coverage = !!strstr(extensions, "NV_framebuffer_multisample_coverage");
 692         space->has_fragment_program2 = !!strstr(extensions, "NV_fragment_program2");
 693         space->has_gpu_program4 = !!strstr(extensions, "NV_gpu_program4");
 694
 695         space->msaa_samples = 16; /* optimistic value, will be downgraded if necessary */
 696
 697         // TODO: this is true on nVidia G70, which does the equivalent of 2x2 MSAA
 698         space->fastest_polygon_smooth_samples = 4;
 699         space->nicest_polygon_smooth_samples = 4;
 700
 701         space->max_anisotropy = 1.0;
 702         if(strstr(extensions, "EXT_texture_filter_anisotropic"))
 703                 ctx->gl.GetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &space->max_anisotropy);
 704
 705         /* Set up the dummy texture for tex_env_combine with constant color. */
 706         _cairo_gpu_texture_create(ctx, &space->dummy_texture, 1, 1);
 707         _cairo_gl_context_set_active_texture(ctx, _cairo_gl_context_set_texture(ctx, -1, &space->dummy_texture));
 708         ctx->gl.TexImage2D(_cairo_gl_context_active_target(ctx), 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, &dummy_tex_data);
 709         return 0;
 710
 711 fail:
 712         return -1;
 713 }
 714
 715 static inline cairo_bool_t
 716 _cairo_gpu_space_is_frag_supported(cairo_gpu_space_t* space, unsigned frag)
 717 {
 718         if(space->use_frag_prog)
 719                 return 1;
 720         else
 721         {
 722                 unsigned tex0 = (frag >> (FRAG_TEX_SHIFT)) & FRAG_TEX_MASK;
 723                 unsigned tex1 = (frag >> (FRAG_TEX_SHIFT + FRAG_TEX_BITS)) & FRAG_TEX_MASK;
 724                 unsigned tex01 = tex0 | tex1;
 725                 unsigned op = frag & FRAG_OP_MASK;
 726
 727                 if(
 728                         (op && op != (OP_MUL_ALPHA << FRAG_OP_SHIFT))
 729                         || (tex01 & (FRAG_TEX_RADIAL | FRAG_TEX_DISCONTINUOUS))
 730                         || (tex01 & FRAG_TEX_COLOR_MASK) == FRAG_TEX_COLOR_111CA
 731                         || (tex1 & FRAG_TEX_COLOR_MASK) == FRAG_TEX_COLOR_111C
 732                         || (!space->tex_aaaa_111a && (
 733                                         ((tex01 & FRAG_TEX_COLOR_MASK) == FRAG_TEX_COLOR_AAAA)
 734                                         || ((tex01 & FRAG_TEX_COLOR_MASK) == FRAG_TEX_COLOR_111A) ))
 735                                         )
 736                         return 0;
 737
 738                 // 4 is enough for everyone
 739                 if(space->tex_units < 4)
 740                 {
 741                         int n = -1; // first unit has two slots
 742                         if(tex1 && space->tex_units < 2)
 743                                 return 0;
 744
 745                         if(tex0)
 746                         {
 747                                 ++n;
 748
 749                                 if((tex0 & FRAG_TEX_COLOR_MASK) == FRAG_TEX_COLOR_111C)
 750                                         n += 2;
 751                                 else
 752                                 {
 753                                         if((frag & (FRAG_OP_MASK | FRAG_OPPOS_TEX1)) == (OP_MUL_ALPHA << FRAG_OP_SHIFT))
 754                                                 ++n;
 755                                 }
 756                         }
 757
 758                         // slot #1 is unused
 759                         if(!space->crossbar && (frag & FRAG_OPPOS_TEX1))
 760                                 ++n;
 761
 762                         if((frag & (FRAG_OP_MASK | FRAG_OPPOS_TEX1)) == ((OP_MUL_ALPHA << FRAG_OP_SHIFT) | FRAG_OPPOS_TEX1))
 763                                 ++n;
 764
 765                         if(tex1)
 766                                 ++n;
 767
 768                         if(frag & (FRAG_CONSTANT | FRAG_PRIMARY))
 769                                 ++n;
 770
 771                         if(n > space->tex_units)
 772                                 return 0;
 773                 }
 774         }
 775         return 1;
 776 }
 777
 778 static cairo_space_t*
 779 _cairo_gpu_space__finish_create(cairo_gpu_space_t* space, unsigned flags)
 780 {
 781         cairo_gpu_context_t* ctx;
 782         int init;
 783         const char* env = getenv("__CAIRO_GPU_GL_FLAGS");
 784         if(env)
 785                 flags |= atoi(env);
 786
 787         _cairo_gpu_enter();
 788
 789         // this calls _cairo_gpu_space__init
 790         ctx = _cairo_gpu_space_bind(space);
 791         init = _cairo_gpu_space__init(ctx, flags);
 792
 793         if(init)
 794         {
 795                 _cairo_gpu_space__destroy(space);
 796                 space = 0;
 797         }
 798         _cairo_gpu_exit();
 799         return (cairo_space_t*)space;
 800 }
 801
 802 cairo_space_t *
 803 cairo_gl_space_create_from_current_context(void* libgl, unsigned flags)
 804 {
 805         cairo_space_t* space;
 806
 807         space = cairo_glx_space_create_from_current_context(libgl, flags);
 808         if(space)
 809                 return space;
 810
 811         space = cairo_osmesa_space_create_from_current_context(libgl, flags);
 812         if(space)
 813                 return space;
 814
 815         return 0;
 816 }
 817
 818 cairo_public cairo_gl_api_t
 819 cairo_gl_space_get_api(cairo_space_t * abstract_space)
 820 {
 821         cairo_gpu_space_t *space = (cairo_gpu_space_t*)abstract_space;
 822
 823         if(abstract_space->backend != &_cairo_gpu_space_backend)
 824                 return CAIRO_GL_API_NONE;
 825
 826         return space->api;
 827 }
 828
 829 cairo_public void*
 830 cairo_gl_space_get_libgl(cairo_space_t * abstract_space)
 831 {
 832         cairo_gpu_space_t *space = (cairo_gpu_space_t*)abstract_space;
 833
 834         if(abstract_space->backend != &_cairo_gpu_space_backend)
 835                 return 0;
 836
 837         return space->libgl;
 838 }
 839
 840 void*
 841 cairo_gl_space_get_proc_address(cairo_space_t * abstract_space, const char* name)
 842 {
 843         cairo_gpu_space_t *space = (cairo_gpu_space_t*)abstract_space;
 844
 845         if(abstract_space->backend != &_cairo_gpu_space_backend)
 846                 return 0;
 847
 848         return space->GetProcAddress(name);
 849 }
 850
 851 void*
 852 cairo_gl_space_create_context(cairo_space_t * abstract_space, cairo_surface_t* surface)
 853 {
 854         cairo_gpu_space_t *space = (cairo_gpu_space_t*)abstract_space;
 855
 856         if(abstract_space->backend != &_cairo_gpu_space_backend)
 857                 return 0;
 858
 859         if(surface && surface->backend != &_cairo_gpu_surface_backend)
 860                 return 0;
 861
 862         return API_SPACE(create_gl_context)(space, surface);
 863 }
 864
 865 void
 866 cairo_gl_space_destroy_context(cairo_space_t * abstract_space, void* context)
 867 {
 868         cairo_gpu_space_t *space = (cairo_gpu_space_t*)abstract_space;
 869
 870         if(abstract_space->backend != &_cairo_gpu_space_backend)
 871                 return;
 872
 873         API_SPACE(destroy_gl_context)(space, context);
 874 }
 875
 876 cairo_bool_t
 877 cairo_gl_space_make_current(cairo_space_t* abstract_space, void* context, cairo_surface_t* abstract_draw_surface, cairo_surface_t* abstract_read_surface)
 878 {
 879         cairo_gpu_space_t* space = (cairo_gpu_space_t*)abstract_space;
 880         cairo_gpu_surface_t* read_surface = (cairo_gpu_surface_t*)abstract_read_surface;
 881         cairo_gpu_surface_t* draw_surface = (cairo_gpu_surface_t*)abstract_draw_surface;
 882         int api = 0;
 883
 884         if(read_surface)
 885         {
 886                 if(read_surface->base.backend != &_cairo_gpu_surface_backend)
 887                         return 0;
 888                 api = read_surface->space->api;
 889         }
 890
 891         if(draw_surface)
 892         {
 893                 if(draw_surface->base.backend != &_cairo_gpu_surface_backend)
 894                         return 0;
 895                 if(api && api != draw_surface->space->api)
 896                         return 0;
 897
 898                 api = draw_surface->space->api;
 899         }
 900
 901         if(!api)
 902         {
 903                 if(!space)
 904                         return 0;
 905                 if(space->base.backend != &_cairo_gpu_space_backend)
 906                         return 0;
 907                 api = space->api;
 908         }
 909
 910         return API_SPACE(make_gl_context_current)(space, context, draw_surface, read_surface);
 911 }