Merge remote-tracking branch 'origin/master' into pipe-video

5 files changed, 53 insertions, 136 deletions

diff --git a/src/gallium/auxiliary/cso_cache/cso_cache.c b/src/gallium/auxiliary/cso_cache/cso_cache.c
index 900c64df4b9..c6069927b25 100644
--- a/src/gallium/auxiliary/cso_cache/cso_cache.c
+++ b/src/gallium/auxiliary/cso_cache/cso_cache.c
@@ -37,13 +37,7 @@
 
 
 struct cso_cache {
-   struct cso_hash *blend_hash;
-   struct cso_hash *depth_stencil_hash;
-   struct cso_hash *fs_hash;
-   struct cso_hash *vs_hash;
-   struct cso_hash *rasterizer_hash;
-   struct cso_hash *sampler_hash;
-   struct cso_hash *velements_hash;
+   struct cso_hash *hashes[CSO_CACHE_MAX];
    int    max_size;
 
    cso_sanitize_callback sanitize_cb;
@@ -86,34 +80,10 @@ unsigned cso_construct_key(void *item, int item_size)
    return hash_key((item), item_size);
 }
 
-static struct cso_hash *_cso_hash_for_type(struct cso_cache *sc, enum cso_cache_type type)
+static INLINE struct cso_hash *_cso_hash_for_type(struct cso_cache *sc, enum cso_cache_type type)
 {
-   struct cso_hash *hash = 0;
-
-   switch(type) {
-   case CSO_BLEND:
-      hash = sc->blend_hash;
-      break;
-   case CSO_SAMPLER:
-      hash = sc->sampler_hash;
-      break;
-   case CSO_DEPTH_STENCIL_ALPHA:
-      hash = sc->depth_stencil_hash;
-      break;
-   case CSO_RASTERIZER:
-      hash = sc->rasterizer_hash;
-      break;
-   case CSO_FRAGMENT_SHADER:
-      hash = sc->fs_hash;
-      break;
-   case CSO_VERTEX_SHADER:
-      hash = sc->vs_hash;
-      break;
-   case CSO_VELEMENTS:
-      hash = sc->velements_hash;
-      break;
-   }
-
+   struct cso_hash *hash;
+   hash = sc->hashes[type];
    return hash;
 }
 
@@ -298,17 +268,14 @@ void * cso_take_state(struct cso_cache *sc,
 struct cso_cache *cso_cache_create(void)
 {
    struct cso_cache *sc = MALLOC_STRUCT(cso_cache);
+   int i;
    if (sc == NULL)
       return NULL;
 
    sc->max_size           = 4096;
-   sc->blend_hash         = cso_hash_create();
-   sc->sampler_hash       = cso_hash_create();
-   sc->depth_stencil_hash = cso_hash_create();
-   sc->rasterizer_hash    = cso_hash_create();
-   sc->fs_hash            = cso_hash_create();
-   sc->vs_hash            = cso_hash_create();
-   sc->velements_hash     = cso_hash_create();
+   for (i = 0; i < CSO_CACHE_MAX; i++)
+      sc->hashes[i] = cso_hash_create();
+
    sc->sanitize_cb        = sanitize_cb;
    sc->sanitize_data      = 0;
 
@@ -318,33 +285,9 @@ struct cso_cache *cso_cache_create(void)
 void cso_for_each_state(struct cso_cache *sc, enum cso_cache_type type,
                         cso_state_callback func, void *user_data)
 {
-   struct cso_hash *hash = 0;
+   struct cso_hash *hash = _cso_hash_for_type(sc, type);
    struct cso_hash_iter iter;
 
-   switch (type) {
-   case CSO_BLEND:
-      hash = sc->blend_hash;
-      break;
-   case CSO_SAMPLER:
-      hash = sc->sampler_hash;
-      break;
-   case CSO_DEPTH_STENCIL_ALPHA:
-      hash = sc->depth_stencil_hash;
-      break;
-   case CSO_RASTERIZER:
-      hash = sc->rasterizer_hash;
-      break;
-   case CSO_FRAGMENT_SHADER:
-      hash = sc->fs_hash;
-      break;
-   case CSO_VERTEX_SHADER:
-      hash = sc->vs_hash;
-      break;
-   case CSO_VELEMENTS:
-      hash = sc->velements_hash;
-      break;
-   }
-
    iter = cso_hash_first_node(hash);
    while (!cso_hash_iter_is_null(iter)) {
       void *state = cso_hash_iter_data(iter);
@@ -357,6 +300,7 @@ void cso_for_each_state(struct cso_cache *sc, enum cso_cache_type type,
 
 void cso_cache_delete(struct cso_cache *sc)
 {
+   int i;
    assert(sc);
 
    if (!sc)
@@ -371,28 +315,20 @@ void cso_cache_delete(struct cso_cache *sc)
    cso_for_each_state(sc, CSO_SAMPLER, delete_sampler_state, 0);
    cso_for_each_state(sc, CSO_VELEMENTS, delete_velements, 0);
 
-   cso_hash_delete(sc->blend_hash);
-   cso_hash_delete(sc->sampler_hash);
-   cso_hash_delete(sc->depth_stencil_hash);
-   cso_hash_delete(sc->rasterizer_hash);
-   cso_hash_delete(sc->fs_hash);
-   cso_hash_delete(sc->vs_hash);
-   cso_hash_delete(sc->velements_hash);
+   for (i = 0; i < CSO_CACHE_MAX; i++)
+      cso_hash_delete(sc->hashes[i]);
+
    FREE(sc);
 }
 
 void cso_set_maximum_cache_size(struct cso_cache *sc, int number)
 {
+   int i;
+
    sc->max_size = number;
 
-   sanitize_hash(sc, sc->blend_hash, CSO_BLEND, sc->max_size);
-   sanitize_hash(sc, sc->depth_stencil_hash, CSO_DEPTH_STENCIL_ALPHA,
-                 sc->max_size);
-   sanitize_hash(sc, sc->fs_hash, CSO_FRAGMENT_SHADER, sc->max_size);
-   sanitize_hash(sc, sc->vs_hash, CSO_VERTEX_SHADER, sc->max_size);
-   sanitize_hash(sc, sc->rasterizer_hash, CSO_RASTERIZER, sc->max_size);
-   sanitize_hash(sc, sc->sampler_hash, CSO_SAMPLER, sc->max_size);
-   sanitize_hash(sc, sc->velements_hash, CSO_VELEMENTS, sc->max_size);
+   for (i = 0; i < CSO_CACHE_MAX; i++)
+      sanitize_hash(sc, sc->hashes[i], i, sc->max_size);
 }
 
 int cso_maximum_cache_size(const struct cso_cache *sc)
diff --git a/src/gallium/auxiliary/cso_cache/cso_cache.h b/src/gallium/auxiliary/cso_cache/cso_cache.h
index fb09b83c623..1b17423c72b 100644
--- a/src/gallium/auxiliary/cso_cache/cso_cache.h
+++ b/src/gallium/auxiliary/cso_cache/cso_cache.h
@@ -86,13 +86,14 @@ extern "C" {
 #endif
 
 enum cso_cache_type {
+   CSO_RASTERIZER,
    CSO_BLEND,
-   CSO_SAMPLER,
    CSO_DEPTH_STENCIL_ALPHA,
-   CSO_RASTERIZER,
    CSO_FRAGMENT_SHADER,
    CSO_VERTEX_SHADER,
-   CSO_VELEMENTS
+   CSO_SAMPLER,
+   CSO_VELEMENTS,
+   CSO_CACHE_MAX,
 };
 
 typedef void (*cso_state_callback)(void *ctx, void *obj);
diff --git a/src/gallium/auxiliary/tgsi/tgsi_ureg.c b/src/gallium/auxiliary/tgsi/tgsi_ureg.c
index 4564ab81f99..a920741c36b 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_ureg.c
+++ b/src/gallium/auxiliary/tgsi/tgsi_ureg.c
@@ -72,7 +72,7 @@ struct ureg_tokens {
 #define UREG_MAX_SYSTEM_VALUE PIPE_MAX_ATTRIBS
 #define UREG_MAX_OUTPUT PIPE_MAX_ATTRIBS
 #define UREG_MAX_CONSTANT_RANGE 32
-#define UREG_MAX_IMMEDIATE 32
+#define UREG_MAX_IMMEDIATE 256
 #define UREG_MAX_TEMP 256
 #define UREG_MAX_ADDR 2
 #define UREG_MAX_PRED 1
diff --git a/src/gallium/auxiliary/util/u_math.h b/src/gallium/auxiliary/util/u_math.h
index 2ecade5f7e4..65a99fcb394 100644
--- a/src/gallium/auxiliary/util/u_math.h
+++ b/src/gallium/auxiliary/util/u_math.h
@@ -477,10 +477,13 @@ float_to_byte_tex(float f)
 static INLINE unsigned
 util_logbase2(unsigned n)
 {
-   unsigned log2 = 0;
-   while (n >>= 1)
-      ++log2;
-   return log2;
+   unsigned pos = 0;
+   if (n >= 1<<16) { n >>= 16; pos += 16; }
+   if (n >= 1<< 8) { n >>=  8; pos +=  8; }
+   if (n >= 1<< 4) { n >>=  4; pos +=  4; }
+   if (n >= 1<< 2) { n >>=  2; pos +=  2; }
+   if (n >= 1<< 1) {           pos +=  1; }
+   return pos;
 }
 
 
diff --git a/src/gallium/auxiliary/util/u_prim.h b/src/gallium/auxiliary/util/u_prim.h
index 3c851f73401..ca7c67d7c53 100644
--- a/src/gallium/auxiliary/util/u_prim.h
+++ b/src/gallium/auxiliary/util/u_prim.h
@@ -78,55 +78,32 @@ static INLINE boolean u_validate_pipe_prim( unsigned pipe_prim, unsigned nr )
 static INLINE boolean u_trim_pipe_prim( unsigned pipe_prim, unsigned *nr )
 {
    boolean ok = TRUE;
-
-   switch (pipe_prim) {
-   case PIPE_PRIM_POINTS:
-      ok = (*nr >= 1);
-      break;
-   case PIPE_PRIM_LINES:
-      ok = (*nr >= 2);
-      *nr -= (*nr % 2);
-      break;
-   case PIPE_PRIM_LINE_STRIP:
-   case PIPE_PRIM_LINE_LOOP:
-      ok = (*nr >= 2);
-      break;
-   case PIPE_PRIM_TRIANGLES:
-      ok = (*nr >= 3);
-      *nr -= (*nr % 3);
-      break;
-   case PIPE_PRIM_TRIANGLE_STRIP:
-   case PIPE_PRIM_TRIANGLE_FAN:
-   case PIPE_PRIM_POLYGON:
-      ok = (*nr >= 3);
-      break;
-   case PIPE_PRIM_QUADS:
-      ok = (*nr >= 4);
-      *nr -= (*nr % 4);
-      break;
-   case PIPE_PRIM_QUAD_STRIP:
-      ok = (*nr >= 4);
-      *nr -= (*nr % 2);
-      break;
-   case PIPE_PRIM_LINES_ADJACENCY:
-      ok = (*nr >= 4);
-      *nr -= (*nr % 4);
-      break;
-   case PIPE_PRIM_LINE_STRIP_ADJACENCY:
-      ok = (*nr >= 4);
-      break;
-   case PIPE_PRIM_TRIANGLES_ADJACENCY:
-      ok = (*nr >= 6);
-      *nr -= (*nr % 5);
-      break;
-   case PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY:
-      ok = (*nr >= 4);
-      break;
-   default:
-      ok = 0;
-      break;
+   const static int values[][2] = {
+      { 1, 0 }, /* PIPE_PRIM_POINTS */
+      { 2, 2 }, /* PIPE_PRIM_LINES */
+      { 2, 0 }, /* PIPE_PRIM_LINE_LOOP */
+      { 2, 0 }, /* PIPE_PRIM_LINE_STRIP */
+      { 3, 3 }, /* PIPE_PRIM_TRIANGLES */
+      { 3, 0 }, /* PIPE_PRIM_TRIANGLE_STRIP */
+      { 3, 0 }, /* PIPE_PRIM_TRIANGLE_FAN */
+      { 4, 4 }, /* PIPE_PRIM_TRIANGLE_QUADS */
+      { 4, 2 }, /* PIPE_PRIM_TRIANGLE_QUAD_STRIP */
+      { 3, 0 }, /* PIPE_PRIM_TRIANGLE_POLYGON */
+      { 4, 4 }, /* PIPE_PRIM_LINES_ADJACENCY */
+      { 4, 0 }, /* PIPE_PRIM_LINE_STRIP_ADJACENCY */
+      { 6, 5 }, /* PIPE_PRIM_TRIANGLES_ADJACENCY */
+      { 4, 0 }, /* PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY */
+   };
+
+   if (unlikely(pipe_prim >= PIPE_PRIM_MAX)) {
+       *nr = 0;
+       return FALSE;
    }
 
+   ok = (*nr >= values[pipe_prim][0]);
+   if (values[pipe_prim][1])
+       *nr -= (*nr % values[pipe_prim][1]);
+
    if (!ok)
       *nr = 0;