src/gallium/auxiliary/cso_cache/cso_context.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28  /**
  29   * @file
  30   *
  31   * Wrap the cso cache & hash mechanisms in a simplified
  32   * pipe-driver-specific interface.
  33   *
  34   * @author Zack Rusin <zack@tungstengraphics.com>
  35   * @author Keith Whitwell <keith@tungstengraphics.com>
  36   */
  37
  38 #include "pipe/p_state.h"
  39 #include "util/u_memory.h"
  40 #include "tgsi/tgsi_parse.h"
  41
  42 #include "cso_cache/cso_context.h"
  43 #include "cso_cache/cso_cache.h"
  44 #include "cso_cache/cso_hash.h"
  45 #include "cso_context.h"
  46
  47 struct cso_context {
  48    struct pipe_context *pipe;
  49    struct cso_cache *cache;
  50
  51    struct {
  52       void *samplers[PIPE_MAX_SAMPLERS];
  53       unsigned nr_samplers;
  54
  55       void *vertex_samplers[PIPE_MAX_VERTEX_SAMPLERS];
  56       unsigned nr_vertex_samplers;
  57    } hw;
  58
  59    void *samplers[PIPE_MAX_SAMPLERS];
  60    unsigned nr_samplers;
  61
  62    void *vertex_samplers[PIPE_MAX_VERTEX_SAMPLERS];
  63    unsigned nr_vertex_samplers;
  64
  65    unsigned nr_samplers_saved;
  66    void *samplers_saved[PIPE_MAX_SAMPLERS];
  67
  68    unsigned nr_vertex_samplers_saved;
  69    void *vertex_samplers_saved[PIPE_MAX_VERTEX_SAMPLERS];
  70
  71    struct pipe_texture *textures[PIPE_MAX_SAMPLERS];
  72    uint nr_textures;
  73
  74    struct pipe_texture *vertex_textures[PIPE_MAX_VERTEX_SAMPLERS];
  75    uint nr_vertex_textures;
  76
  77    uint nr_textures_saved;
  78    struct pipe_texture *textures_saved[PIPE_MAX_SAMPLERS];
  79
  80    uint nr_vertex_textures_saved;
  81    struct pipe_texture *vertex_textures_saved[PIPE_MAX_SAMPLERS];
  82
  83    /** Current and saved state.
  84     * The saved state is used as a 1-deep stack.
  85     */
  86    void *blend, *blend_saved;
  87    void *depth_stencil, *depth_stencil_saved;
  88    void *rasterizer, *rasterizer_saved;
  89    void *fragment_shader, *fragment_shader_saved, *geometry_shader;
  90    void *vertex_shader, *vertex_shader_saved, *geometry_shader_saved;
  91
  92    struct pipe_framebuffer_state fb, fb_saved;
  93    struct pipe_viewport_state vp, vp_saved;
  94    struct pipe_blend_color blend_color;
  95 };
  96
  97
  98 static void
  99 free_framebuffer_state(struct pipe_framebuffer_state *fb);
 100
 101
 102 static boolean delete_blend_state(struct cso_context *ctx, void *state)
 103 {
 104    struct cso_blend *cso = (struct cso_blend *)state;
 105
 106    if (ctx->blend == cso->data)
 107       return FALSE;
 108
 109    if (cso->delete_state)
 110       cso->delete_state(cso->context, cso->data);
 111    FREE(state);
 112    return TRUE;
 113 }
 114
 115 static boolean delete_depth_stencil_state(struct cso_context *ctx, void *state)
 116 {
 117    struct cso_depth_stencil_alpha *cso = (struct cso_depth_stencil_alpha *)state;
 118
 119    if (ctx->depth_stencil == cso->data)
 120       return FALSE;
 121
 122    if (cso->delete_state)
 123       cso->delete_state(cso->context, cso->data);
 124    FREE(state);
 125
 126    return TRUE;
 127 }
 128
 129 static boolean delete_sampler_state(struct cso_context *ctx, void *state)
 130 {
 131    struct cso_sampler *cso = (struct cso_sampler *)state;
 132    if (cso->delete_state)
 133       cso->delete_state(cso->context, cso->data);
 134    FREE(state);
 135    return TRUE;
 136 }
 137
 138 static boolean delete_rasterizer_state(struct cso_context *ctx, void *state)
 139 {
 140    struct cso_rasterizer *cso = (struct cso_rasterizer *)state;
 141
 142    if (ctx->rasterizer == cso->data)
 143       return FALSE;
 144    if (cso->delete_state)
 145       cso->delete_state(cso->context, cso->data);
 146    FREE(state);
 147    return TRUE;
 148 }
 149
 150 static boolean delete_fs_state(struct cso_context *ctx, void *state)
 151 {
 152    struct cso_fragment_shader *cso = (struct cso_fragment_shader *)state;
 153    if (ctx->fragment_shader == cso->data)
 154       return FALSE;
 155    if (cso->delete_state)
 156       cso->delete_state(cso->context, cso->data);
 157    FREE(state);
 158    return TRUE;
 159 }
 160
 161 static boolean delete_vs_state(struct cso_context *ctx, void *state)
 162 {
 163    struct cso_vertex_shader *cso = (struct cso_vertex_shader *)state;
 164    if (ctx->vertex_shader == cso->data)
 165       return TRUE;
 166    if (cso->delete_state)
 167       cso->delete_state(cso->context, cso->data);
 168    FREE(state);
 169    return FALSE;
 170 }
 171
 172
 173 static INLINE boolean delete_cso(struct cso_context *ctx,
 174                                  void *state, enum cso_cache_type type)
 175 {
 176    switch (type) {
 177    case CSO_BLEND:
 178       return delete_blend_state(ctx, state);
 179       break;
 180    case CSO_SAMPLER:
 181       return delete_sampler_state(ctx, state);
 182       break;
 183    case CSO_DEPTH_STENCIL_ALPHA:
 184       return delete_depth_stencil_state(ctx, state);
 185       break;
 186    case CSO_RASTERIZER:
 187       return delete_rasterizer_state(ctx, state);
 188       break;
 189    case CSO_FRAGMENT_SHADER:
 190       return delete_fs_state(ctx, state);
 191       break;
 192    case CSO_VERTEX_SHADER:
 193       return delete_vs_state(ctx, state);
 194       break;
 195    default:
 196       assert(0);
 197       FREE(state);
 198    }
 199    return FALSE;
 200 }
 201
 202 static INLINE void sanitize_hash(struct cso_hash *hash, enum cso_cache_type type,
 203                                  int max_size, void *user_data)
 204 {
 205    struct cso_context *ctx = (struct cso_context *)user_data;
 206    /* if we're approach the maximum size, remove fourth of the entries
 207     * otherwise every subsequent call will go through the same */
 208    int hash_size = cso_hash_size(hash);
 209    int max_entries = (max_size > hash_size) ? max_size : hash_size;
 210    int to_remove =  (max_size < max_entries) * max_entries/4;
 211    struct cso_hash_iter iter = cso_hash_first_node(hash);
 212    if (hash_size > max_size)
 213       to_remove += hash_size - max_size;
 214    while (to_remove) {
 215       /*remove elements until we're good */
 216       /*fixme: currently we pick the nodes to remove at random*/
 217       void *cso = cso_hash_iter_data(iter);
 218       if (delete_cso(ctx, cso, type)) {
 219          iter = cso_hash_erase(hash, iter);
 220          --to_remove;
 221       } else
 222          iter = cso_hash_iter_next(iter);
 223    }
 224 }
 225
 226
 227 struct cso_context *cso_create_context( struct pipe_context *pipe )
 228 {
 229    struct cso_context *ctx = CALLOC_STRUCT(cso_context);
 230    if (ctx == NULL)
 231       goto out;
 232
 233    ctx->cache = cso_cache_create();
 234    if (ctx->cache == NULL)
 235       goto out;
 236    cso_cache_set_sanitize_callback(ctx->cache,
 237                                    sanitize_hash,
 238                                    ctx);
 239
 240    ctx->pipe = pipe;
 241
 242    /* Enable for testing: */
 243    if (0) cso_set_maximum_cache_size( ctx->cache, 4 );
 244
 245    return ctx;
 246
 247 out:
 248    cso_destroy_context( ctx );
 249    return NULL;
 250 }
 251
 252
 253 /**
 254  * Prior to context destruction, this function unbinds all state objects.
 255  */
 256 void cso_release_all( struct cso_context *ctx )
 257 {
 258    unsigned i;
 259
 260    if (ctx->pipe) {
 261       ctx->pipe->bind_blend_state( ctx->pipe, NULL );
 262       ctx->pipe->bind_rasterizer_state( ctx->pipe, NULL );
 263       ctx->pipe->bind_fragment_sampler_states( ctx->pipe, 0, NULL );
 264       if (ctx->pipe->bind_vertex_sampler_states)
 265          ctx->pipe->bind_vertex_sampler_states(ctx->pipe, 0, NULL);
 266       ctx->pipe->bind_depth_stencil_alpha_state( ctx->pipe, NULL );
 267       ctx->pipe->bind_fs_state( ctx->pipe, NULL );
 268       ctx->pipe->bind_vs_state( ctx->pipe, NULL );
 269    }
 270
 271    for (i = 0; i < PIPE_MAX_SAMPLERS; i++) {
 272       pipe_texture_reference(&ctx->textures[i], NULL);
 273       pipe_texture_reference(&ctx->textures_saved[i], NULL);
 274    }
 275
 276    for (i = 0; i < PIPE_MAX_VERTEX_SAMPLERS; i++) {
 277       pipe_texture_reference(&ctx->vertex_textures[i], NULL);
 278       pipe_texture_reference(&ctx->vertex_textures_saved[i], NULL);
 279    }
 280
 281    free_framebuffer_state(&ctx->fb);
 282    free_framebuffer_state(&ctx->fb_saved);
 283
 284    if (ctx->cache) {
 285       cso_cache_delete( ctx->cache );
 286       ctx->cache = NULL;
 287    }
 288 }
 289
 290
 291 void cso_destroy_context( struct cso_context *ctx )
 292 {
 293    if (ctx) {
 294       /*cso_release_all( ctx );*/
 295       FREE( ctx );
 296    }
 297 }
 298
 299
 300 /* Those function will either find the state of the given template
 301  * in the cache or they will create a new state from the given
 302  * template, insert it in the cache and return it.
 303  */
 304
 305 /*
 306  * If the driver returns 0 from the create method then they will assign
 307  * the data member of the cso to be the template itself.
 308  */
 309
 310 enum pipe_error cso_set_blend(struct cso_context *ctx,
 311                               const struct pipe_blend_state *templ)
 312 {
 313    unsigned hash_key = cso_construct_key((void*)templ, sizeof(struct pipe_blend_state));
 314    struct cso_hash_iter iter = cso_find_state_template(ctx->cache,
 315                                                        hash_key, CSO_BLEND,
 316                                                        (void*)templ);
 317    void *handle;
 318
 319    if (cso_hash_iter_is_null(iter)) {
 320       struct cso_blend *cso = MALLOC(sizeof(struct cso_blend));
 321       if (!cso)
 322          return PIPE_ERROR_OUT_OF_MEMORY;
 323
 324       memcpy(&cso->state, templ, sizeof(*templ));
 325       cso->data = ctx->pipe->create_blend_state(ctx->pipe, &cso->state);
 326       cso->delete_state = (cso_state_callback)ctx->pipe->delete_blend_state;
 327       cso->context = ctx->pipe;
 328
 329       iter = cso_insert_state(ctx->cache, hash_key, CSO_BLEND, cso);
 330       if (cso_hash_iter_is_null(iter)) {
 331          FREE(cso);
 332          return PIPE_ERROR_OUT_OF_MEMORY;
 333       }
 334
 335       handle = cso->data;
 336    }
 337    else {
 338       handle = ((struct cso_blend *)cso_hash_iter_data(iter))->data;
 339    }
 340
 341    if (ctx->blend != handle) {
 342       ctx->blend = handle;
 343       ctx->pipe->bind_blend_state(ctx->pipe, handle);
 344    }
 345    return PIPE_OK;
 346 }
 347
 348 void cso_save_blend(struct cso_context *ctx)
 349 {
 350    assert(!ctx->blend_saved);
 351    ctx->blend_saved = ctx->blend;
 352 }
 353
 354 void cso_restore_blend(struct cso_context *ctx)
 355 {
 356    if (ctx->blend != ctx->blend_saved) {
 357       ctx->blend = ctx->blend_saved;
 358       ctx->pipe->bind_blend_state(ctx->pipe, ctx->blend_saved);
 359    }
 360    ctx->blend_saved = NULL;
 361 }
 362
 363
 364
 365 enum pipe_error cso_single_sampler(struct cso_context *ctx,
 366                                    unsigned idx,
 367                                    const struct pipe_sampler_state *templ)
 368 {
 369    void *handle = NULL;
 370
 371    if (templ != NULL) {
 372       unsigned hash_key = cso_construct_key((void*)templ, sizeof(struct pipe_sampler_state));
 373       struct cso_hash_iter iter = cso_find_state_template(ctx->cache,
 374                                                           hash_key, CSO_SAMPLER,
 375                                                           (void*)templ);
 376
 377       if (cso_hash_iter_is_null(iter)) {
 378          struct cso_sampler *cso = MALLOC(sizeof(struct cso_sampler));
 379          if (!cso)
 380             return PIPE_ERROR_OUT_OF_MEMORY;
 381
 382          memcpy(&cso->state, templ, sizeof(*templ));
 383          cso->data = ctx->pipe->create_sampler_state(ctx->pipe, &cso->state);
 384          cso->delete_state = (cso_state_callback)ctx->pipe->delete_sampler_state;
 385          cso->context = ctx->pipe;
 386
 387          iter = cso_insert_state(ctx->cache, hash_key, CSO_SAMPLER, cso);
 388          if (cso_hash_iter_is_null(iter)) {
 389             FREE(cso);
 390             return PIPE_ERROR_OUT_OF_MEMORY;
 391          }
 392
 393          handle = cso->data;
 394       }
 395       else {
 396          handle = ((struct cso_sampler *)cso_hash_iter_data(iter))->data;
 397       }
 398    }
 399
 400    ctx->samplers[idx] = handle;
 401    return PIPE_OK;
 402 }
 403
 404 enum pipe_error
 405 cso_single_vertex_sampler(struct cso_context *ctx,
 406                           unsigned idx,
 407                           const struct pipe_sampler_state *templ)
 408 {
 409    void *handle = NULL;
 410
 411    if (templ != NULL) {
 412       unsigned hash_key = cso_construct_key((void*)templ, sizeof(struct pipe_sampler_state));
 413       struct cso_hash_iter iter = cso_find_state_template(ctx->cache,
 414                                                           hash_key, CSO_SAMPLER,
 415                                                           (void*)templ);
 416
 417       if (cso_hash_iter_is_null(iter)) {
 418          struct cso_sampler *cso = MALLOC(sizeof(struct cso_sampler));
 419          if (!cso)
 420             return PIPE_ERROR_OUT_OF_MEMORY;
 421
 422          memcpy(&cso->state, templ, sizeof(*templ));
 423          cso->data = ctx->pipe->create_sampler_state(ctx->pipe, &cso->state);
 424          cso->delete_state = (cso_state_callback)ctx->pipe->delete_sampler_state;
 425          cso->context = ctx->pipe;
 426
 427          iter = cso_insert_state(ctx->cache, hash_key, CSO_SAMPLER, cso);
 428          if (cso_hash_iter_is_null(iter)) {
 429             FREE(cso);
 430             return PIPE_ERROR_OUT_OF_MEMORY;
 431          }
 432
 433          handle = cso->data;
 434       }
 435       else {
 436          handle = ((struct cso_sampler *)cso_hash_iter_data(iter))->data;
 437       }
 438    }
 439
 440    ctx->vertex_samplers[idx] = handle;
 441    return PIPE_OK;
 442 }
 443
 444 void cso_single_sampler_done( struct cso_context *ctx )
 445 {
 446    unsigned i;
 447
 448    /* find highest non-null sampler */
 449    for (i = PIPE_MAX_SAMPLERS; i > 0; i--) {
 450       if (ctx->samplers[i - 1] != NULL)
 451          break;
 452    }
 453
 454    ctx->nr_samplers = i;
 455
 456    if (ctx->hw.nr_samplers != ctx->nr_samplers ||
 457        memcmp(ctx->hw.samplers,
 458               ctx->samplers,
 459               ctx->nr_samplers * sizeof(void *)) != 0)
 460    {
 461       memcpy(ctx->hw.samplers, ctx->samplers, ctx->nr_samplers * sizeof(void *));
 462       ctx->hw.nr_samplers = ctx->nr_samplers;
 463
 464       ctx->pipe->bind_fragment_sampler_states(ctx->pipe, ctx->nr_samplers, ctx->samplers);
 465    }
 466 }
 467
 468 void
 469 cso_single_vertex_sampler_done(struct cso_context *ctx)
 470 {
 471    unsigned i;
 472
 473    /* find highest non-null sampler */
 474    for (i = PIPE_MAX_VERTEX_SAMPLERS; i > 0; i--) {
 475       if (ctx->vertex_samplers[i - 1] != NULL)
 476          break;
 477    }
 478
 479    ctx->nr_vertex_samplers = i;
 480
 481    if (ctx->hw.nr_vertex_samplers != ctx->nr_vertex_samplers ||
 482        memcmp(ctx->hw.vertex_samplers,
 483               ctx->vertex_samplers,
 484               ctx->nr_vertex_samplers * sizeof(void *)) != 0)
 485    {
 486       memcpy(ctx->hw.vertex_samplers,
 487              ctx->vertex_samplers,
 488              ctx->nr_vertex_samplers * sizeof(void *));
 489       ctx->hw.nr_vertex_samplers = ctx->nr_vertex_samplers;
 490
 491       ctx->pipe->bind_vertex_sampler_states(ctx->pipe,
 492                                             ctx->nr_vertex_samplers,
 493                                             ctx->vertex_samplers);
 494    }
 495 }
 496
 497 /*
 498  * If the function encouters any errors it will return the
 499  * last one. Done to always try to set as many samplers
 500  * as possible.
 501  */
 502 enum pipe_error cso_set_samplers( struct cso_context *ctx,
 503                                   unsigned nr,
 504                                   const struct pipe_sampler_state **templates )
 505 {
 506    unsigned i;
 507    enum pipe_error temp, error = PIPE_OK;
 508
 509    /* TODO: fastpath
 510     */
 511
 512    for (i = 0; i < nr; i++) {
 513       temp = cso_single_sampler( ctx, i, templates[i] );
 514       if (temp != PIPE_OK)
 515          error = temp;
 516    }
 517
 518    for ( ; i < ctx->nr_samplers; i++) {
 519       temp = cso_single_sampler( ctx, i, NULL );
 520       if (temp != PIPE_OK)
 521          error = temp;
 522    }
 523
 524    cso_single_sampler_done( ctx );
 525
 526    return error;
 527 }
 528
 529 void cso_save_samplers(struct cso_context *ctx)
 530 {
 531    ctx->nr_samplers_saved = ctx->nr_samplers;
 532    memcpy(ctx->samplers_saved, ctx->samplers, sizeof(ctx->samplers));
 533 }
 534
 535 void cso_restore_samplers(struct cso_context *ctx)
 536 {
 537    ctx->nr_samplers = ctx->nr_samplers_saved;
 538    memcpy(ctx->samplers, ctx->samplers_saved, sizeof(ctx->samplers));
 539    cso_single_sampler_done( ctx );
 540 }
 541
 542 void
 543 cso_save_vertex_samplers(struct cso_context *ctx)
 544 {
 545    ctx->nr_vertex_samplers_saved = ctx->nr_vertex_samplers;
 546    memcpy(ctx->vertex_samplers_saved, ctx->vertex_samplers, sizeof(ctx->vertex_samplers));
 547 }
 548
 549 void
 550 cso_restore_vertex_samplers(struct cso_context *ctx)
 551 {
 552    ctx->nr_vertex_samplers = ctx->nr_vertex_samplers_saved;
 553    memcpy(ctx->vertex_samplers, ctx->vertex_samplers_saved, sizeof(ctx->vertex_samplers));
 554    cso_single_vertex_sampler_done(ctx);
 555 }
 556
 557
 558 enum pipe_error cso_set_sampler_textures( struct cso_context *ctx,
 559                                           uint count,
 560                                           struct pipe_texture **textures )
 561 {
 562    uint i;
 563
 564    ctx->nr_textures = count;
 565
 566    for (i = 0; i < count; i++)
 567       pipe_texture_reference(&ctx->textures[i], textures[i]);
 568    for ( ; i < PIPE_MAX_SAMPLERS; i++)
 569       pipe_texture_reference(&ctx->textures[i], NULL);
 570
 571    ctx->pipe->set_fragment_sampler_textures(ctx->pipe, count, textures);
 572
 573    return PIPE_OK;
 574 }
 575
 576 void cso_save_sampler_textures( struct cso_context *ctx )
 577 {
 578    uint i;
 579
 580    ctx->nr_textures_saved = ctx->nr_textures;
 581    for (i = 0; i < ctx->nr_textures; i++) {
 582       assert(!ctx->textures_saved[i]);
 583       pipe_texture_reference(&ctx->textures_saved[i], ctx->textures[i]);
 584    }
 585 }
 586
 587 void cso_restore_sampler_textures( struct cso_context *ctx )
 588 {
 589    uint i;
 590
 591    ctx->nr_textures = ctx->nr_textures_saved;
 592
 593    for (i = 0; i < ctx->nr_textures; i++) {
 594       pipe_texture_reference(&ctx->textures[i], NULL);
 595       ctx->textures[i] = ctx->textures_saved[i];
 596       ctx->textures_saved[i] = NULL;
 597    }
 598    for ( ; i < PIPE_MAX_SAMPLERS; i++)
 599       pipe_texture_reference(&ctx->textures[i], NULL);
 600
 601    ctx->pipe->set_fragment_sampler_textures(ctx->pipe, ctx->nr_textures, ctx->textures);
 602
 603    ctx->nr_textures_saved = 0;
 604 }
 605
 606
 607
 608 enum pipe_error
 609 cso_set_vertex_sampler_textures(struct cso_context *ctx,
 610                                 uint count,
 611                                 struct pipe_texture **textures)
 612 {
 613    uint i;
 614
 615    ctx->nr_vertex_textures = count;
 616
 617    for (i = 0; i < count; i++) {
 618       pipe_texture_reference(&ctx->vertex_textures[i], textures[i]);
 619    }
 620    for ( ; i < PIPE_MAX_VERTEX_SAMPLERS; i++) {
 621       pipe_texture_reference(&ctx->vertex_textures[i], NULL);
 622    }
 623
 624    ctx->pipe->set_vertex_sampler_textures(ctx->pipe, count, textures);
 625
 626    return PIPE_OK;
 627 }
 628
 629 void
 630 cso_save_vertex_sampler_textures(struct cso_context *ctx)
 631 {
 632    uint i;
 633
 634    ctx->nr_vertex_textures_saved = ctx->nr_vertex_textures;
 635    for (i = 0; i < ctx->nr_vertex_textures; i++) {
 636       assert(!ctx->vertex_textures_saved[i]);
 637       pipe_texture_reference(&ctx->vertex_textures_saved[i], ctx->vertex_textures[i]);
 638    }
 639 }
 640
 641 void
 642 cso_restore_vertex_sampler_textures(struct cso_context *ctx)
 643 {
 644    uint i;
 645
 646    ctx->nr_vertex_textures = ctx->nr_vertex_textures_saved;
 647
 648    for (i = 0; i < ctx->nr_vertex_textures; i++) {
 649       pipe_texture_reference(&ctx->vertex_textures[i], NULL);
 650       ctx->vertex_textures[i] = ctx->vertex_textures_saved[i];
 651       ctx->vertex_textures_saved[i] = NULL;
 652    }
 653    for ( ; i < PIPE_MAX_VERTEX_SAMPLERS; i++) {
 654       pipe_texture_reference(&ctx->vertex_textures[i], NULL);
 655    }
 656
 657    ctx->pipe->set_vertex_sampler_textures(ctx->pipe,
 658                                           ctx->nr_vertex_textures,
 659                                           ctx->vertex_textures);
 660
 661    ctx->nr_vertex_textures_saved = 0;
 662 }
 663
 664
 665
 666 enum pipe_error cso_set_depth_stencil_alpha(struct cso_context *ctx,
 667                                             const struct pipe_depth_stencil_alpha_state *templ)
 668 {
 669    unsigned hash_key = cso_construct_key((void*)templ,
 670                                          sizeof(struct pipe_depth_stencil_alpha_state));
 671    struct cso_hash_iter iter = cso_find_state_template(ctx->cache,
 672                                                        hash_key,
 673                                                        CSO_DEPTH_STENCIL_ALPHA,
 674                                                        (void*)templ);
 675    void *handle;
 676
 677    if (cso_hash_iter_is_null(iter)) {
 678       struct cso_depth_stencil_alpha *cso = MALLOC(sizeof(struct cso_depth_stencil_alpha));
 679       if (!cso)
 680          return PIPE_ERROR_OUT_OF_MEMORY;
 681
 682       memcpy(&cso->state, templ, sizeof(*templ));
 683       cso->data = ctx->pipe->create_depth_stencil_alpha_state(ctx->pipe, &cso->state);
 684       cso->delete_state = (cso_state_callback)ctx->pipe->delete_depth_stencil_alpha_state;
 685       cso->context = ctx->pipe;
 686
 687       iter = cso_insert_state(ctx->cache, hash_key, CSO_DEPTH_STENCIL_ALPHA, cso);
 688       if (cso_hash_iter_is_null(iter)) {
 689          FREE(cso);
 690          return PIPE_ERROR_OUT_OF_MEMORY;
 691       }
 692
 693       handle = cso->data;
 694    }
 695    else {
 696       handle = ((struct cso_depth_stencil_alpha *)cso_hash_iter_data(iter))->data;
 697    }
 698
 699    if (ctx->depth_stencil != handle) {
 700       ctx->depth_stencil = handle;
 701       ctx->pipe->bind_depth_stencil_alpha_state(ctx->pipe, handle);
 702    }
 703    return PIPE_OK;
 704 }
 705
 706 void cso_save_depth_stencil_alpha(struct cso_context *ctx)
 707 {
 708    assert(!ctx->depth_stencil_saved);
 709    ctx->depth_stencil_saved = ctx->depth_stencil;
 710 }
 711
 712 void cso_restore_depth_stencil_alpha(struct cso_context *ctx)
 713 {
 714    if (ctx->depth_stencil != ctx->depth_stencil_saved) {
 715       ctx->depth_stencil = ctx->depth_stencil_saved;
 716       ctx->pipe->bind_depth_stencil_alpha_state(ctx->pipe, ctx->depth_stencil_saved);
 717    }
 718    ctx->depth_stencil_saved = NULL;
 719 }
 720
 721
 722
 723 enum pipe_error cso_set_rasterizer(struct cso_context *ctx,
 724                                    const struct pipe_rasterizer_state *templ)
 725 {
 726    unsigned hash_key = cso_construct_key((void*)templ,
 727                                          sizeof(struct pipe_rasterizer_state));
 728    struct cso_hash_iter iter = cso_find_state_template(ctx->cache,
 729                                                        hash_key, CSO_RASTERIZER,
 730                                                        (void*)templ);
 731    void *handle = NULL;
 732
 733    if (cso_hash_iter_is_null(iter)) {
 734       struct cso_rasterizer *cso = MALLOC(sizeof(struct cso_rasterizer));
 735       if (!cso)
 736          return PIPE_ERROR_OUT_OF_MEMORY;
 737
 738       memcpy(&cso->state, templ, sizeof(*templ));
 739       cso->data = ctx->pipe->create_rasterizer_state(ctx->pipe, &cso->state);
 740       cso->delete_state = (cso_state_callback)ctx->pipe->delete_rasterizer_state;
 741       cso->context = ctx->pipe;
 742
 743       iter = cso_insert_state(ctx->cache, hash_key, CSO_RASTERIZER, cso);
 744       if (cso_hash_iter_is_null(iter)) {
 745          FREE(cso);
 746          return PIPE_ERROR_OUT_OF_MEMORY;
 747       }
 748
 749       handle = cso->data;
 750    }
 751    else {
 752       handle = ((struct cso_rasterizer *)cso_hash_iter_data(iter))->data;
 753    }
 754
 755    if (ctx->rasterizer != handle) {
 756       ctx->rasterizer = handle;
 757       ctx->pipe->bind_rasterizer_state(ctx->pipe, handle);
 758    }
 759    return PIPE_OK;
 760 }
 761
 762 void cso_save_rasterizer(struct cso_context *ctx)
 763 {
 764    assert(!ctx->rasterizer_saved);
 765    ctx->rasterizer_saved = ctx->rasterizer;
 766 }
 767
 768 void cso_restore_rasterizer(struct cso_context *ctx)
 769 {
 770    if (ctx->rasterizer != ctx->rasterizer_saved) {
 771       ctx->rasterizer = ctx->rasterizer_saved;
 772       ctx->pipe->bind_rasterizer_state(ctx->pipe, ctx->rasterizer_saved);
 773    }
 774    ctx->rasterizer_saved = NULL;
 775 }
 776
 777
 778
 779 enum pipe_error cso_set_fragment_shader_handle(struct cso_context *ctx,
 780                                                void *handle )
 781 {
 782    if (ctx->fragment_shader != handle) {
 783       ctx->fragment_shader = handle;
 784       ctx->pipe->bind_fs_state(ctx->pipe, handle);
 785    }
 786    return PIPE_OK;
 787 }
 788
 789 void cso_delete_fragment_shader(struct cso_context *ctx, void *handle )
 790 {
 791    if (handle == ctx->fragment_shader) {
 792       /* unbind before deleting */
 793       ctx->pipe->bind_fs_state(ctx->pipe, NULL);
 794       ctx->fragment_shader = NULL;
 795    }
 796    ctx->pipe->delete_fs_state(ctx->pipe, handle);
 797 }
 798
 799 /* Not really working:
 800  */
 801 #if 0
 802 enum pipe_error cso_set_fragment_shader(struct cso_context *ctx,
 803                                         const struct pipe_shader_state *templ)
 804 {
 805    const struct tgsi_token *tokens = templ->tokens;
 806    unsigned num_tokens = tgsi_num_tokens(tokens);
 807    size_t tokens_size = num_tokens*sizeof(struct tgsi_token);
 808    unsigned hash_key = cso_construct_key((void*)tokens, tokens_size);
 809    struct cso_hash_iter iter = cso_find_state_template(ctx->cache,
 810                                                        hash_key,
 811                                                        CSO_FRAGMENT_SHADER,
 812                                                        (void*)tokens);
 813    void *handle = NULL;
 814
 815    if (cso_hash_iter_is_null(iter)) {
 816       struct cso_fragment_shader *cso = MALLOC(sizeof(struct cso_fragment_shader) + tokens_size);
 817       struct tgsi_token *cso_tokens = (struct tgsi_token *)((char *)cso + sizeof(*cso));
 818
 819       if (!cso)
 820          return PIPE_ERROR_OUT_OF_MEMORY;
 821
 822       memcpy(cso_tokens, tokens, tokens_size);
 823       cso->state.tokens = cso_tokens;
 824       cso->data = ctx->pipe->create_fs_state(ctx->pipe, &cso->state);
 825       cso->delete_state = (cso_state_callback)ctx->pipe->delete_fs_state;
 826       cso->context = ctx->pipe;
 827
 828       iter = cso_insert_state(ctx->cache, hash_key, CSO_FRAGMENT_SHADER, cso);
 829       if (cso_hash_iter_is_null(iter)) {
 830          FREE(cso);
 831          return PIPE_ERROR_OUT_OF_MEMORY;
 832       }
 833
 834       handle = cso->data;
 835    }
 836    else {
 837       handle = ((struct cso_fragment_shader *)cso_hash_iter_data(iter))->data;
 838    }
 839
 840    return cso_set_fragment_shader_handle( ctx, handle );
 841 }
 842 #endif
 843
 844 void cso_save_fragment_shader(struct cso_context *ctx)
 845 {
 846    assert(!ctx->fragment_shader_saved);
 847    ctx->fragment_shader_saved = ctx->fragment_shader;
 848 }
 849
 850 void cso_restore_fragment_shader(struct cso_context *ctx)
 851 {
 852    if (ctx->fragment_shader_saved != ctx->fragment_shader) {
 853       ctx->pipe->bind_fs_state(ctx->pipe, ctx->fragment_shader_saved);
 854       ctx->fragment_shader = ctx->fragment_shader_saved;
 855    }
 856    ctx->fragment_shader_saved = NULL;
 857 }
 858
 859
 860 enum pipe_error cso_set_vertex_shader_handle(struct cso_context *ctx,
 861                                              void *handle )
 862 {
 863    if (ctx->vertex_shader != handle) {
 864       ctx->vertex_shader = handle;
 865       ctx->pipe->bind_vs_state(ctx->pipe, handle);
 866    }
 867    return PIPE_OK;
 868 }
 869
 870 void cso_delete_vertex_shader(struct cso_context *ctx, void *handle )
 871 {
 872    if (handle == ctx->vertex_shader) {
 873       /* unbind before deleting */
 874       ctx->pipe->bind_vs_state(ctx->pipe, NULL);
 875       ctx->vertex_shader = NULL;
 876    }
 877    ctx->pipe->delete_vs_state(ctx->pipe, handle);
 878 }
 879
 880
 881 /* Not really working:
 882  */
 883 #if 0
 884 enum pipe_error cso_set_vertex_shader(struct cso_context *ctx,
 885                                       const struct pipe_shader_state *templ)
 886 {
 887    unsigned hash_key = cso_construct_key((void*)templ,
 888                                          sizeof(struct pipe_shader_state));
 889    struct cso_hash_iter iter = cso_find_state_template(ctx->cache,
 890                                                        hash_key, CSO_VERTEX_SHADER,
 891                                                        (void*)templ);
 892    void *handle = NULL;
 893
 894    if (cso_hash_iter_is_null(iter)) {
 895       struct cso_vertex_shader *cso = MALLOC(sizeof(struct cso_vertex_shader));
 896
 897       if (!cso)
 898          return PIPE_ERROR_OUT_OF_MEMORY;
 899
 900       memcpy(cso->state, templ, sizeof(*templ));
 901       cso->data = ctx->pipe->create_vs_state(ctx->pipe, &cso->state);
 902       cso->delete_state = (cso_state_callback)ctx->pipe->delete_vs_state;
 903       cso->context = ctx->pipe;
 904
 905       iter = cso_insert_state(ctx->cache, hash_key, CSO_VERTEX_SHADER, cso);
 906       if (cso_hash_iter_is_null(iter)) {
 907          FREE(cso);
 908          return PIPE_ERROR_OUT_OF_MEMORY;
 909       }
 910
 911       handle = cso->data;
 912    }
 913    else {
 914       handle = ((struct cso_vertex_shader *)cso_hash_iter_data(iter))->data;
 915    }
 916
 917    return cso_set_vertex_shader_handle( ctx, handle );
 918 }
 919 #endif
 920
 921
 922
 923 void cso_save_vertex_shader(struct cso_context *ctx)
 924 {
 925    assert(!ctx->vertex_shader_saved);
 926    ctx->vertex_shader_saved = ctx->vertex_shader;
 927 }
 928
 929 void cso_restore_vertex_shader(struct cso_context *ctx)
 930 {
 931    if (ctx->vertex_shader_saved != ctx->vertex_shader) {
 932       ctx->pipe->bind_vs_state(ctx->pipe, ctx->vertex_shader_saved);
 933       ctx->vertex_shader = ctx->vertex_shader_saved;
 934    }
 935    ctx->vertex_shader_saved = NULL;
 936 }
 937
 938
 939 /**
 940  * Copy framebuffer state from src to dst with refcounting of surfaces.
 941  */
 942 static void
 943 copy_framebuffer_state(struct pipe_framebuffer_state *dst,
 944                        const struct pipe_framebuffer_state *src)
 945 {
 946    uint i;
 947
 948    dst->width = src->width;
 949    dst->height = src->height;
 950    dst->nr_cbufs = src->nr_cbufs;
 951    for (i = 0; i < PIPE_MAX_COLOR_BUFS; i++) {
 952       pipe_surface_reference(&dst->cbufs[i], src->cbufs[i]);
 953    }
 954    pipe_surface_reference(&dst->zsbuf, src->zsbuf);
 955 }
 956
 957
 958 static void
 959 free_framebuffer_state(struct pipe_framebuffer_state *fb)
 960 {
 961    uint i;
 962
 963    for (i = 0; i < PIPE_MAX_COLOR_BUFS; i++) {
 964       pipe_surface_reference(&fb->cbufs[i], NULL);
 965    }
 966    pipe_surface_reference(&fb->zsbuf, NULL);
 967 }
 968
 969
 970 enum pipe_error cso_set_framebuffer(struct cso_context *ctx,
 971                                     const struct pipe_framebuffer_state *fb)
 972 {
 973    if (memcmp(&ctx->fb, fb, sizeof(*fb)) != 0) {
 974       copy_framebuffer_state(&ctx->fb, fb);
 975       ctx->pipe->set_framebuffer_state(ctx->pipe, fb);
 976    }
 977    return PIPE_OK;
 978 }
 979
 980 void cso_save_framebuffer(struct cso_context *ctx)
 981 {
 982    copy_framebuffer_state(&ctx->fb_saved, &ctx->fb);
 983 }
 984
 985 void cso_restore_framebuffer(struct cso_context *ctx)
 986 {
 987    if (memcmp(&ctx->fb, &ctx->fb_saved, sizeof(ctx->fb))) {
 988       copy_framebuffer_state(&ctx->fb, &ctx->fb_saved);
 989       ctx->pipe->set_framebuffer_state(ctx->pipe, &ctx->fb);
 990       free_framebuffer_state(&ctx->fb_saved);
 991    }
 992 }
 993
 994
 995 enum pipe_error cso_set_viewport(struct cso_context *ctx,
 996                                  const struct pipe_viewport_state *vp)
 997 {
 998    if (memcmp(&ctx->vp, vp, sizeof(*vp))) {
 999       ctx->vp = *vp;
1000       ctx->pipe->set_viewport_state(ctx->pipe, vp);
1001    }
1002    return PIPE_OK;
1003 }
1004
1005 void cso_save_viewport(struct cso_context *ctx)
1006 {
1007    ctx->vp_saved = ctx->vp;
1008 }
1009
1010
1011 void cso_restore_viewport(struct cso_context *ctx)
1012 {
1013    if (memcmp(&ctx->vp, &ctx->vp_saved, sizeof(ctx->vp))) {
1014       ctx->vp = ctx->vp_saved;
1015       ctx->pipe->set_viewport_state(ctx->pipe, &ctx->vp);
1016    }
1017 }
1018
1019
1020
1021
1022 enum pipe_error cso_set_blend_color(struct cso_context *ctx,
1023                                     const struct pipe_blend_color *bc)
1024 {
1025    if (memcmp(&ctx->blend_color, bc, sizeof(ctx->blend_color))) {
1026       ctx->blend_color = *bc;
1027       ctx->pipe->set_blend_color(ctx->pipe, bc);
1028    }
1029    return PIPE_OK;
1030 }
1031
1032 enum pipe_error cso_set_geometry_shader_handle(struct cso_context *ctx,
1033                                                void *handle)
1034 {
1035    if (ctx->geometry_shader != handle) {
1036       ctx->geometry_shader = handle;
1037       ctx->pipe->bind_gs_state(ctx->pipe, handle);
1038    }
1039    return PIPE_OK;
1040 }
1041
1042 void cso_delete_geometry_shader(struct cso_context *ctx, void *handle)
1043 {
1044     if (handle == ctx->geometry_shader) {
1045       /* unbind before deleting */
1046       ctx->pipe->bind_gs_state(ctx->pipe, NULL);
1047       ctx->geometry_shader = NULL;
1048    }
1049    ctx->pipe->delete_gs_state(ctx->pipe, handle);
1050 }
1051
1052 void cso_save_geometry_shader(struct cso_context *ctx)
1053 {
1054    assert(!ctx->geometry_shader_saved);
1055    ctx->geometry_shader_saved = ctx->geometry_shader;
1056 }
1057
1058 void cso_restore_geometry_shader(struct cso_context *ctx)
1059 {
1060    if (ctx->geometry_shader_saved != ctx->geometry_shader) {
1061       ctx->pipe->bind_gs_state(ctx->pipe, ctx->geometry_shader_saved);
1062       ctx->geometry_shader = ctx->geometry_shader_saved;
1063    }
1064    ctx->geometry_shader_saved = NULL;
1065 }