← Back to branch summary

~ubuntu-branches/ubuntu/precise/mesa/precise-updates

« back to all changes in this revision

Viewing changes to src/gallium/drivers/softpipe/sp_state_so.c

  • Committer: Package Import Robot
  • Author(s): Robert Hooker
  • Date: 2012-02-02 12:05:48 UTC
  • mfrom: (1.7.1) (3.3.27 sid)
  • Revision ID: package-import@ubuntu.com-20120202120548-nvkma85jq0h4coix
Tags: 8.0~rc2-0ubuntu4
Drop drisearchdir handling, it is no longer needed with multiarch
and dri-alternates being removed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gallium/drivers/softpipe/sp_state_so.c
32
32
#include "util/u_format.h"
33
33
#include "util/u_memory.h"
34
34
#include "draw/draw_context.h"
35
 
 
36
 
 
37
 
static void *
38
 
softpipe_create_stream_output_state(struct pipe_context *pipe,
39
 
                                    const struct pipe_stream_output_state *templ)
40
 
{
41
 
   struct sp_so_state *so;
42
 
   so = (struct sp_so_state *) CALLOC_STRUCT(sp_so_state);
43
 
 
44
 
   if (so) {
45
 
      so->base.num_outputs = templ->num_outputs;
46
 
      so->base.stride = templ->stride;
47
 
      memcpy(so->base.output_buffer,
48
 
             templ->output_buffer,
49
 
             sizeof(int) * templ->num_outputs);
50
 
      memcpy(so->base.register_index,
51
 
             templ->register_index,
52
 
             sizeof(int) * templ->num_outputs);
53
 
      memcpy(so->base.register_mask,
54
 
             templ->register_mask,
55
 
             sizeof(ubyte) * templ->num_outputs);
56
 
   }
57
 
   return so;
58
 
}
59
 
 
60
 
 
61
 
static void
62
 
softpipe_bind_stream_output_state(struct pipe_context *pipe,
63
 
                                  void *so)
64
 
{
65
 
   struct softpipe_context *softpipe = softpipe_context(pipe);
66
 
   struct sp_so_state *sp_so = (struct sp_so_state *) so;
67
 
 
68
 
   softpipe->so = sp_so;
69
 
 
70
 
   softpipe->dirty |= SP_NEW_SO;
71
 
 
72
 
   if (sp_so)
73
 
      draw_set_so_state(softpipe->draw, &sp_so->base);
74
 
}
75
 
 
76
 
 
77
 
static void
78
 
softpipe_delete_stream_output_state(struct pipe_context *pipe, void *so)
79
 
{
80
 
   FREE( so );
81
 
}
82
 
 
83
 
 
84
 
static void
85
 
softpipe_set_stream_output_buffers(struct pipe_context *pipe,
86
 
                                   struct pipe_resource **buffers,
87
 
                                   int *offsets,
88
 
                                   int num_buffers)
 
35
#include "pipebuffer/pb_buffer.h"
 
36
 
 
37
static struct pipe_stream_output_target *
 
38
softpipe_create_so_target(struct pipe_context *pipe,
 
39
                          struct pipe_resource *buffer,
 
40
                          unsigned buffer_offset,
 
41
                          unsigned buffer_size)
 
42
{
 
43
   struct draw_so_target *t;
 
44
 
 
45
   t = CALLOC_STRUCT(draw_so_target);
 
46
   t->target.context = pipe;
 
47
   t->target.reference.count = 1;
 
48
   pipe_resource_reference(&t->target.buffer, buffer);
 
49
   t->target.buffer_offset = buffer_offset;
 
50
   t->target.buffer_size = buffer_size;
 
51
   return &t->target;
 
52
}
 
53
 
 
54
static void
 
55
softpipe_so_target_destroy(struct pipe_context *pipe,
 
56
                           struct pipe_stream_output_target *target)
 
57
{
 
58
   pipe_resource_reference(&target->buffer, NULL);
 
59
   FREE(target);
 
60
}
 
61
 
 
62
static void
 
63
softpipe_set_so_targets(struct pipe_context *pipe,
 
64
                        unsigned num_targets,
 
65
                        struct pipe_stream_output_target **targets,
 
66
                        unsigned append_bitmask)
89
67
{
90
68
   struct softpipe_context *softpipe = softpipe_context(pipe);
91
69
   int i;
92
 
   void *map_buffers[PIPE_MAX_SO_BUFFERS];
93
 
 
94
 
   assert(num_buffers <= PIPE_MAX_SO_BUFFERS);
95
 
   if (num_buffers > PIPE_MAX_SO_BUFFERS)
96
 
      num_buffers = PIPE_MAX_SO_BUFFERS;
97
 
 
98
 
   softpipe->dirty |= SP_NEW_SO_BUFFERS;
99
 
 
100
 
   for (i = 0; i < num_buffers; ++i) {
101
 
      void *mapped;
102
 
      struct softpipe_resource *res = softpipe_resource(buffers[i]);
103
 
 
104
 
      if (!res) {
105
 
         /* the whole call is invalid, bail out */
106
 
         softpipe->so_target.num_buffers = 0;
107
 
         draw_set_mapped_so_buffers(softpipe->draw, 0, 0);
108
 
         return;
109
 
      }
110
 
 
111
 
      softpipe->so_target.buffer[i] = res;
112
 
      softpipe->so_target.offset[i] = offsets[i];
113
 
      softpipe->so_target.so_count[i] = 0;
114
 
 
115
 
      mapped = res->data;
116
 
      if (offsets[i] >= 0)
117
 
         map_buffers[i] = ((char*)mapped) + offsets[i];
118
 
      else {
119
 
         /* this is a buffer append */
120
 
         assert(!"appending not implemented");
121
 
         map_buffers[i] = mapped;
122
 
      }
123
 
   }
124
 
   softpipe->so_target.num_buffers = num_buffers;
125
 
 
126
 
   draw_set_mapped_so_buffers(softpipe->draw, map_buffers, num_buffers);
 
70
 
 
71
   for (i = 0; i < num_targets; i++) {
 
72
      pipe_so_target_reference((struct pipe_stream_output_target **)&softpipe->so_targets[i], targets[i]);
 
73
   }
 
74
 
 
75
   for (; i < softpipe->num_so_targets; i++) {
 
76
      pipe_so_target_reference((struct pipe_stream_output_target **)&softpipe->so_targets[i], NULL);
 
77
   }
 
78
 
 
79
   softpipe->num_so_targets = num_targets;
127
80
}
128
81
 
129
 
 
130
 
 
131
82
void
132
83
softpipe_init_streamout_funcs(struct pipe_context *pipe)
133
84
{
134
 
   pipe->create_stream_output_state = softpipe_create_stream_output_state;
135
 
   pipe->bind_stream_output_state = softpipe_bind_stream_output_state;
136
 
   pipe->delete_stream_output_state = softpipe_delete_stream_output_state;
137
 
 
138
 
   pipe->set_stream_output_buffers = softpipe_set_stream_output_buffers;
 
85
   pipe->create_stream_output_target = softpipe_create_so_target;
 
86
   pipe->stream_output_target_destroy = softpipe_so_target_destroy;
 
87
   pipe->set_stream_output_targets = softpipe_set_so_targets;
139
88
}
140
89