radeonsi: stop using v16i8

[mesa.git] / src / gallium / auxiliary / draw / draw_pt_so_emit.c

diff --git a/src/gallium/auxiliary/draw/draw_pt_so_emit.c b/src/gallium/auxiliary/draw/draw_pt_so_emit.c
index 64ed5441e7c8615e30bd6acff4af06e8a4471ab0..261bd3467f9e929bf2f5c1133429572d642a0ab8 100644 (file)
--- a/src/gallium/auxiliary/draw/draw_pt_so_emit.c
+++ b/src/gallium/auxiliary/draw/draw_pt_so_emit.c
@@ -43,12 +43,11 @@ struct pt_so_emit {
 
    unsigned input_vertex_stride;
    const float (*inputs)[4];
-   const float (*pre_clip_pos)[4];
+   const float *pre_clip_pos;
    boolean has_so;
    boolean use_pre_clip_pos;
    int pos_idx;
    unsigned emitted_primitives;
-   unsigned emitted_vertices;
    unsigned generated_primitives;
 };
 
@@ -66,7 +65,7 @@ draw_so_info(const struct draw_context *draw)
    return state;
 }
 
-static INLINE boolean
+static inline boolean
 draw_has_so(const struct draw_context *draw)
 {
    const struct pipe_stream_output_info *state = draw_so_info(draw);
@@ -116,10 +115,11 @@ static void so_emit_prim(struct pt_so_emit *so,
    unsigned input_vertex_stride = so->input_vertex_stride;
    struct draw_context *draw = so->draw;
    const float (*input_ptr)[4];
-   const float (*pcp_ptr)[4] = NULL;
+   const float *pcp_ptr = NULL;
    const struct pipe_stream_output_info *state = draw_so_info(draw);
    float *buffer;
    int buffer_total_bytes[PIPE_MAX_SO_BUFFERS];
+   boolean buffer_written[PIPE_MAX_SO_BUFFERS] = {0};
 
    input_ptr = so->inputs;
    if (so->use_pre_clip_pos)
@@ -129,33 +129,46 @@ static void so_emit_prim(struct pt_so_emit *so,
 
    for (i = 0; i < draw->so.num_targets; i++) {
       struct draw_so_target *target = draw->so.targets[i];
-      buffer_total_bytes[i] = target->internal_offset;
+      if (target) {
+         buffer_total_bytes[i] = target->internal_offset;
+      } else {
+         buffer_total_bytes[i] = 0;
+      }
    }
 
    /* check have we space to emit prim first - if not don't do anything */
    for (i = 0; i < num_vertices; ++i) {
+      unsigned ob;
       for (slot = 0; slot < state->num_outputs; ++slot) {
          unsigned num_comps = state->output[slot].num_components;
          int ob = state->output[slot].output_buffer;
-
-         if ((buffer_total_bytes[ob] + num_comps * sizeof(float)) >
+         unsigned dst_offset = state->output[slot].dst_offset * sizeof(float);
+         unsigned write_size = num_comps * sizeof(float);
+         /* If a buffer is missing then that's equivalent to
+          * an overflow */
+         if (!draw->so.targets[ob]) {
+            return;
+         }
+         if ((buffer_total_bytes[ob] + write_size + dst_offset) >
              draw->so.targets[ob]->target.buffer_size) {
             return;
          }
-         buffer_total_bytes[ob] += num_comps * sizeof(float);
+      }
+      for (ob = 0; ob < draw->so.num_targets; ++ob) {
+         buffer_total_bytes[ob] += state->stride[ob] * sizeof(float);
       }
    }
 
    for (i = 0; i < num_vertices; ++i) {
       const float (*input)[4];
-      const float (*pre_clip_pos)[4];
-      int ob;
+      const float *pre_clip_pos = NULL;
+      unsigned  ob;
 
       input = (const float (*)[4])(
          (const char *)input_ptr + (indices[i] * input_vertex_stride));
 
       if (pcp_ptr)
-         pre_clip_pos = (const float (*)[4])(
+         pre_clip_pos = (const float *)(
          (const char *)pcp_ptr + (indices[i] * input_vertex_stride));
 
       for (slot = 0; slot < state->num_outputs; ++slot) {
@@ -164,20 +177,41 @@ static void so_emit_prim(struct pt_so_emit *so,
          unsigned num_comps = state->output[slot].num_components;
 
          ob = state->output[slot].output_buffer;
+         buffer_written[ob] = TRUE;
 
          buffer = (float *)((char *)draw->so.targets[ob]->mapping +
                             draw->so.targets[ob]->target.buffer_offset +
-                            draw->so.targets[ob]->internal_offset) + state->output[slot].dst_offset;
+                            draw->so.targets[ob]->internal_offset) +
+            state->output[slot].dst_offset;
          
          if (idx == so->pos_idx && pcp_ptr)
-            memcpy(buffer, &pre_clip_pos[idx][start_comp], num_comps * sizeof(float));
+            memcpy(buffer, &pre_clip_pos[start_comp],
+                   num_comps * sizeof(float));
          else
-            memcpy(buffer, &input[idx][start_comp], num_comps * sizeof(float));
+            memcpy(buffer, &input[idx][start_comp],
+                   num_comps * sizeof(float));
+#if 0
+         {
+            int j;
+            debug_printf("VERT[%d], offset = %d, slot[%d] sc = %d, num_c = %d, idx = %d = [",
+                         i,
+                         draw->so.targets[ob]->internal_offset,
+                         slot, start_comp, num_comps, idx);
+            for (j = 0; j < num_comps; ++j) {
+               unsigned *ubuffer = (unsigned*)buffer;
+               debug_printf("%d (0x%x), ", ubuffer[j], ubuffer[j]);
+            }
+            debug_printf("]\n");
+         }
+#endif
+      }
+      for (ob = 0; ob < draw->so.num_targets; ++ob) {
+         struct draw_so_target *target = draw->so.targets[ob];
+         if (target && buffer_written[ob]) {
+            target->internal_offset += state->stride[ob] * sizeof(float);
+         }
       }
-      for (ob = 0; ob < draw->so.num_targets; ++ob)
-         draw->so.targets[ob]->internal_offset += state->stride[ob] * sizeof(float);
    }
-   so->emitted_vertices += num_vertices;
    ++so->emitted_primitives;
 }
 
@@ -237,12 +271,11 @@ void draw_pt_so_emit( struct pt_so_emit *emit,
    if (!draw->so.num_targets)
       return;
 
-   emit->emitted_vertices = 0;
    emit->emitted_primitives = 0;
    emit->generated_primitives = 0;
    emit->input_vertex_stride = input_verts->stride;
    if (emit->use_pre_clip_pos)
-     emit->pre_clip_pos = (const float (*)[4])input_verts->verts->pre_clip_pos;
+      emit->pre_clip_pos = input_verts->verts->clip_pos;
 
    emit->inputs = (const float (*)[4])input_verts->verts->data;
 
@@ -265,7 +298,6 @@ void draw_pt_so_emit( struct pt_so_emit *emit,
 
    render->set_stream_output_info(render,
                                   emit->emitted_primitives,
-                                  emit->emitted_vertices,
                                   emit->generated_primitives);
 }