1 /**************************************************************************
3 * Copyright 2010 Christian König
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:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
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.
26 **************************************************************************/
29 #include "util/u_format.h"
30 #include "vl_vertex_buffers.h"
33 /* vertices for a quad covering a block */
34 static const struct vertex2f block_quad
[4] = {
35 {0.0f
, 0.0f
}, {1.0f
, 0.0f
}, {1.0f
, 1.0f
}, {0.0f
, 1.0f
}
38 struct pipe_vertex_buffer
39 vl_vb_upload_quads(struct pipe_context
*pipe
)
41 struct pipe_vertex_buffer quad
;
42 struct pipe_transfer
*buf_transfer
;
50 quad
.stride
= sizeof(struct vertex2f
);
51 quad
.buffer_offset
= 0;
52 quad
.buffer
= pipe_buffer_create
55 PIPE_BIND_VERTEX_BUFFER
,
57 sizeof(struct vertex2f
) * 4
59 quad
.user_buffer
= NULL
;
69 PIPE_TRANSFER_WRITE
| PIPE_TRANSFER_DISCARD_RANGE
,
73 for (i
= 0; i
< 4; ++i
, ++v
) {
74 v
->x
= block_quad
[i
].x
;
75 v
->y
= block_quad
[i
].y
;
78 pipe_buffer_unmap(pipe
, buf_transfer
);
83 struct pipe_vertex_buffer
84 vl_vb_upload_pos(struct pipe_context
*pipe
, unsigned width
, unsigned height
)
86 struct pipe_vertex_buffer pos
;
87 struct pipe_transfer
*buf_transfer
;
95 pos
.stride
= sizeof(struct vertex2s
);
96 pos
.buffer_offset
= 0;
97 pos
.buffer
= pipe_buffer_create
100 PIPE_BIND_VERTEX_BUFFER
,
102 sizeof(struct vertex2s
) * width
* height
104 pos
.user_buffer
= NULL
;
114 PIPE_TRANSFER_WRITE
| PIPE_TRANSFER_DISCARD_RANGE
,
118 for ( y
= 0; y
< height
; ++y
) {
119 for ( x
= 0; x
< width
; ++x
, ++v
) {
125 pipe_buffer_unmap(pipe
, buf_transfer
);
130 static struct pipe_vertex_element
131 vl_vb_get_quad_vertex_element(void)
133 struct pipe_vertex_element element
;
135 /* setup rectangle element */
136 element
.src_offset
= 0;
137 element
.instance_divisor
= 0;
138 element
.vertex_buffer_index
= 0;
139 element
.src_format
= PIPE_FORMAT_R32G32_FLOAT
;
145 vl_vb_element_helper(struct pipe_vertex_element
* elements
, unsigned num_elements
,
146 unsigned vertex_buffer_index
)
148 unsigned i
, offset
= 0;
150 assert(elements
&& num_elements
);
152 for ( i
= 0; i
< num_elements
; ++i
) {
153 elements
[i
].src_offset
= offset
;
154 elements
[i
].instance_divisor
= 1;
155 elements
[i
].vertex_buffer_index
= vertex_buffer_index
;
156 offset
+= util_format_get_blocksize(elements
[i
].src_format
);
161 vl_vb_get_ves_ycbcr(struct pipe_context
*pipe
)
163 struct pipe_vertex_element vertex_elems
[NUM_VS_INPUTS
];
167 memset(&vertex_elems
, 0, sizeof(vertex_elems
));
168 vertex_elems
[VS_I_RECT
] = vl_vb_get_quad_vertex_element();
170 /* Position element */
171 vertex_elems
[VS_I_VPOS
].src_format
= PIPE_FORMAT_R8G8B8A8_USCALED
;
173 /* block num element */
174 vertex_elems
[VS_I_BLOCK_NUM
].src_format
= PIPE_FORMAT_R32_FLOAT
;
176 vl_vb_element_helper(&vertex_elems
[VS_I_VPOS
], 2, 1);
178 return pipe
->create_vertex_elements_state(pipe
, 3, vertex_elems
);
182 vl_vb_get_ves_mv(struct pipe_context
*pipe
)
184 struct pipe_vertex_element vertex_elems
[NUM_VS_INPUTS
];
188 memset(&vertex_elems
, 0, sizeof(vertex_elems
));
189 vertex_elems
[VS_I_RECT
] = vl_vb_get_quad_vertex_element();
191 /* Position element */
192 vertex_elems
[VS_I_VPOS
].src_format
= PIPE_FORMAT_R16G16_SSCALED
;
194 vl_vb_element_helper(&vertex_elems
[VS_I_VPOS
], 1, 1);
196 /* motion vector TOP element */
197 vertex_elems
[VS_I_MV_TOP
].src_format
= PIPE_FORMAT_R16G16B16A16_SSCALED
;
199 /* motion vector BOTTOM element */
200 vertex_elems
[VS_I_MV_BOTTOM
].src_format
= PIPE_FORMAT_R16G16B16A16_SSCALED
;
202 vl_vb_element_helper(&vertex_elems
[VS_I_MV_TOP
], 2, 2);
204 return pipe
->create_vertex_elements_state(pipe
, NUM_VS_INPUTS
, vertex_elems
);
208 vl_vb_init(struct vl_vertex_buffer
*buffer
, struct pipe_context
*pipe
,
209 unsigned width
, unsigned height
)
215 buffer
->width
= width
;
216 buffer
->height
= height
;
218 size
= width
* height
;
220 for (i
= 0; i
< VL_NUM_COMPONENTS
; ++i
) {
221 buffer
->ycbcr
[i
].resource
= pipe_buffer_create
224 PIPE_BIND_VERTEX_BUFFER
,
226 sizeof(struct vl_ycbcr_block
) * size
* 4
228 if (!buffer
->ycbcr
[i
].resource
)
232 for (i
= 0; i
< VL_MAX_REF_FRAMES
; ++i
) {
233 buffer
->mv
[i
].resource
= pipe_buffer_create
236 PIPE_BIND_VERTEX_BUFFER
,
238 sizeof(struct vl_motionvector
) * size
240 if (!buffer
->mv
[i
].resource
)
244 vl_vb_map(buffer
, pipe
);
248 for (i
= 0; i
< VL_NUM_COMPONENTS
; ++i
)
249 pipe_resource_reference(&buffer
->mv
[i
].resource
, NULL
);
252 for (i
= 0; i
< VL_NUM_COMPONENTS
; ++i
)
253 pipe_resource_reference(&buffer
->ycbcr
[i
].resource
, NULL
);
258 vl_vb_attributes_per_plock(struct vl_vertex_buffer
*buffer
)
263 struct pipe_vertex_buffer
264 vl_vb_get_ycbcr(struct vl_vertex_buffer
*buffer
, int component
)
266 struct pipe_vertex_buffer buf
;
270 buf
.stride
= sizeof(struct vl_ycbcr_block
);
271 buf
.buffer_offset
= 0;
272 buf
.buffer
= buffer
->ycbcr
[component
].resource
;
273 buf
.user_buffer
= NULL
;
278 struct pipe_vertex_buffer
279 vl_vb_get_mv(struct vl_vertex_buffer
*buffer
, int motionvector
)
281 struct pipe_vertex_buffer buf
;
285 buf
.stride
= sizeof(struct vl_motionvector
);
286 buf
.buffer_offset
= 0;
287 buf
.buffer
= buffer
->mv
[motionvector
].resource
;
288 buf
.user_buffer
= NULL
;
294 vl_vb_map(struct vl_vertex_buffer
*buffer
, struct pipe_context
*pipe
)
298 assert(buffer
&& pipe
);
300 for (i
= 0; i
< VL_NUM_COMPONENTS
; ++i
) {
301 buffer
->ycbcr
[i
].vertex_stream
= pipe_buffer_map
304 buffer
->ycbcr
[i
].resource
,
305 PIPE_TRANSFER_WRITE
| PIPE_TRANSFER_DISCARD_RANGE
,
306 &buffer
->ycbcr
[i
].transfer
310 for (i
= 0; i
< VL_MAX_REF_FRAMES
; ++i
) {
311 buffer
->mv
[i
].vertex_stream
= pipe_buffer_map
314 buffer
->mv
[i
].resource
,
315 PIPE_TRANSFER_WRITE
| PIPE_TRANSFER_DISCARD_RANGE
,
316 &buffer
->mv
[i
].transfer
322 struct vl_ycbcr_block
*
323 vl_vb_get_ycbcr_stream(struct vl_vertex_buffer
*buffer
, int component
)
326 assert(component
< VL_NUM_COMPONENTS
);
328 return buffer
->ycbcr
[component
].vertex_stream
;
332 vl_vb_get_mv_stream_stride(struct vl_vertex_buffer
*buffer
)
336 return buffer
->width
;
339 struct vl_motionvector
*
340 vl_vb_get_mv_stream(struct vl_vertex_buffer
*buffer
, int ref_frame
)
343 assert(ref_frame
< VL_MAX_REF_FRAMES
);
345 return buffer
->mv
[ref_frame
].vertex_stream
;
349 vl_vb_unmap(struct vl_vertex_buffer
*buffer
, struct pipe_context
*pipe
)
353 assert(buffer
&& pipe
);
355 for (i
= 0; i
< VL_NUM_COMPONENTS
; ++i
) {
356 pipe_buffer_unmap(pipe
, buffer
->ycbcr
[i
].transfer
);
359 for (i
= 0; i
< VL_MAX_REF_FRAMES
; ++i
) {
360 pipe_buffer_unmap(pipe
, buffer
->mv
[i
].transfer
);
365 vl_vb_cleanup(struct vl_vertex_buffer
*buffer
)
371 for (i
= 0; i
< VL_NUM_COMPONENTS
; ++i
) {
372 pipe_resource_reference(&buffer
->ycbcr
[i
].resource
, NULL
);
375 for (i
= 0; i
< VL_MAX_REF_FRAMES
; ++i
) {
376 pipe_resource_reference(&buffer
->mv
[i
].resource
, NULL
);