1 /**************************************************************************
3 * Copyright 2009 Younes Manton.
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 **************************************************************************/
30 #include <pipe/p_context.h>
32 #include <util/u_sampler.h>
33 #include <util/u_draw.h>
35 #include <tgsi/tgsi_ureg.h>
37 #include "vl_defines.h"
38 #include "vl_vertex_buffers.h"
48 VS_O_FLAGS
= VS_O_VTOP
,
49 VS_O_VTEX
= VS_O_VBOTTOM
52 static struct ureg_dst
53 calc_position(struct vl_mc
*r
, struct ureg_program
*shader
, struct ureg_src block_scale
)
55 struct ureg_src vrect
, vpos
;
56 struct ureg_dst t_vpos
;
57 struct ureg_dst o_vpos
;
59 vrect
= ureg_DECL_vs_input(shader
, VS_I_RECT
);
60 vpos
= ureg_DECL_vs_input(shader
, VS_I_VPOS
);
62 t_vpos
= ureg_DECL_temporary(shader
);
64 o_vpos
= ureg_DECL_output(shader
, TGSI_SEMANTIC_POSITION
, VS_O_VPOS
);
67 * block_scale = (MACROBLOCK_WIDTH, MACROBLOCK_HEIGHT) / (dst.width, dst.height)
69 * t_vpos = (vpos + vrect) * block_scale
73 ureg_ADD(shader
, ureg_writemask(t_vpos
, TGSI_WRITEMASK_XY
), vpos
, vrect
);
74 ureg_MUL(shader
, ureg_writemask(t_vpos
, TGSI_WRITEMASK_XY
), ureg_src(t_vpos
), block_scale
);
75 ureg_MOV(shader
, ureg_writemask(o_vpos
, TGSI_WRITEMASK_XY
), ureg_src(t_vpos
));
76 ureg_MOV(shader
, ureg_writemask(o_vpos
, TGSI_WRITEMASK_ZW
), ureg_imm1f(shader
, 1.0f
));
81 static struct ureg_dst
82 calc_line(struct ureg_program
*shader
)
87 tmp
= ureg_DECL_temporary(shader
);
89 pos
= ureg_DECL_fs_input(shader
, TGSI_SEMANTIC_POSITION
, VS_O_VPOS
, TGSI_INTERPOLATE_LINEAR
);
92 * tmp.y = fraction(pos.y / 2) >= 0.5 ? 1 : 0
94 ureg_MUL(shader
, ureg_writemask(tmp
, TGSI_WRITEMASK_Y
), pos
, ureg_imm1f(shader
, 0.5f
));
95 ureg_FRC(shader
, ureg_writemask(tmp
, TGSI_WRITEMASK_Y
), ureg_src(tmp
));
96 ureg_SGE(shader
, ureg_writemask(tmp
, TGSI_WRITEMASK_Y
), ureg_src(tmp
), ureg_imm1f(shader
, 0.5f
));
102 create_ref_vert_shader(struct vl_mc
*r
)
104 struct ureg_program
*shader
;
105 struct ureg_src mv_scale
;
106 struct ureg_src vrect
, vmv
[2];
107 struct ureg_dst t_vpos
;
108 struct ureg_dst o_vpos
, o_vmv
[2];
111 shader
= ureg_create(TGSI_PROCESSOR_VERTEX
);
115 vrect
= ureg_DECL_vs_input(shader
, VS_I_RECT
);
116 vmv
[0] = ureg_DECL_vs_input(shader
, VS_I_MV_TOP
);
117 vmv
[1] = ureg_DECL_vs_input(shader
, VS_I_MV_BOTTOM
);
119 t_vpos
= calc_position(r
, shader
, ureg_imm2f(shader
,
120 (float)MACROBLOCK_WIDTH
/ r
->buffer_width
,
121 (float)MACROBLOCK_HEIGHT
/ r
->buffer_height
)
124 o_vpos
= ureg_DECL_output(shader
, TGSI_SEMANTIC_POSITION
, VS_O_VPOS
);
125 o_vmv
[0] = ureg_DECL_output(shader
, TGSI_SEMANTIC_GENERIC
, VS_O_VTOP
);
126 o_vmv
[1] = ureg_DECL_output(shader
, TGSI_SEMANTIC_GENERIC
, VS_O_VBOTTOM
);
129 * mv_scale.xy = 0.5 / (dst.width, dst.height);
130 * mv_scale.z = 1.0f / 4.0f
131 * mv_scale.w = 1.0f / 255.0f
133 * // Apply motion vectors
134 * o_vmv[0..1].xy = vmv[0..1] * mv_scale + t_vpos
135 * o_vmv[0..1].zw = vmv[0..1] * mv_scale
139 mv_scale
= ureg_imm4f(shader
,
140 0.5f
/ r
->buffer_width
,
141 0.5f
/ r
->buffer_height
,
143 1.0f
/ PIPE_VIDEO_MV_WEIGHT_MAX
);
145 for (i
= 0; i
< 2; ++i
) {
146 ureg_MAD(shader
, ureg_writemask(o_vmv
[i
], TGSI_WRITEMASK_XY
), mv_scale
, vmv
[i
], ureg_src(t_vpos
));
147 ureg_MUL(shader
, ureg_writemask(o_vmv
[i
], TGSI_WRITEMASK_ZW
), mv_scale
, vmv
[i
]);
150 ureg_release_temporary(shader
, t_vpos
);
154 return ureg_create_shader_and_destroy(shader
, r
->pipe
);
158 create_ref_frag_shader(struct vl_mc
*r
)
160 const float y_scale
=
161 r
->buffer_height
/ 2 *
162 r
->macroblock_size
/ MACROBLOCK_HEIGHT
;
164 struct ureg_program
*shader
;
165 struct ureg_src tc
[2], sampler
;
166 struct ureg_dst ref
, field
;
167 struct ureg_dst fragment
;
170 shader
= ureg_create(TGSI_PROCESSOR_FRAGMENT
);
174 tc
[0] = ureg_DECL_fs_input(shader
, TGSI_SEMANTIC_GENERIC
, VS_O_VTOP
, TGSI_INTERPOLATE_LINEAR
);
175 tc
[1] = ureg_DECL_fs_input(shader
, TGSI_SEMANTIC_GENERIC
, VS_O_VBOTTOM
, TGSI_INTERPOLATE_LINEAR
);
177 sampler
= ureg_DECL_sampler(shader
, 0);
178 ref
= ureg_DECL_temporary(shader
);
180 fragment
= ureg_DECL_output(shader
, TGSI_SEMANTIC_COLOR
, 0);
182 field
= calc_line(shader
);
185 * ref = field.z ? tc[1] : tc[0]
187 * // Adjust tc acording to top/bottom field selection
190 * ref.y = floor(ref.y)
194 * fragment.xyz = tex(ref, sampler[0])
196 ureg_CMP(shader
, ureg_writemask(ref
, TGSI_WRITEMASK_XYZ
),
197 ureg_negate(ureg_scalar(ureg_src(field
), TGSI_SWIZZLE_Y
)),
199 ureg_CMP(shader
, ureg_writemask(fragment
, TGSI_WRITEMASK_W
),
200 ureg_negate(ureg_scalar(ureg_src(field
), TGSI_SWIZZLE_Y
)),
203 ureg_IF(shader
, ureg_scalar(ureg_src(ref
), TGSI_SWIZZLE_Z
), &label
);
205 ureg_MUL(shader
, ureg_writemask(ref
, TGSI_WRITEMASK_Y
),
206 ureg_src(ref
), ureg_imm1f(shader
, y_scale
));
207 ureg_FLR(shader
, ureg_writemask(ref
, TGSI_WRITEMASK_Y
), ureg_src(ref
));
208 ureg_ADD(shader
, ureg_writemask(ref
, TGSI_WRITEMASK_Y
),
209 ureg_src(ref
), ureg_scalar(ureg_src(ref
), TGSI_SWIZZLE_Z
));
210 ureg_MUL(shader
, ureg_writemask(ref
, TGSI_WRITEMASK_Y
),
211 ureg_src(ref
), ureg_imm1f(shader
, 1.0f
/ y_scale
));
213 ureg_fixup_label(shader
, label
, ureg_get_instruction_number(shader
));
216 ureg_TEX(shader
, ureg_writemask(fragment
, TGSI_WRITEMASK_XYZ
), TGSI_TEXTURE_2D
, ureg_src(ref
), sampler
);
218 ureg_release_temporary(shader
, ref
);
220 ureg_release_temporary(shader
, field
);
223 return ureg_create_shader_and_destroy(shader
, r
->pipe
);
227 create_ycbcr_vert_shader(struct vl_mc
*r
, vl_mc_ycbcr_vert_shader vs_callback
, void *callback_priv
)
229 struct ureg_program
*shader
;
231 struct ureg_src vrect
, vpos
;
232 struct ureg_dst t_vpos
, t_vtex
;
233 struct ureg_dst o_vpos
, o_flags
;
235 struct vertex2f scale
= {
236 (float)BLOCK_WIDTH
/ r
->buffer_width
* MACROBLOCK_WIDTH
/ r
->macroblock_size
,
237 (float)BLOCK_HEIGHT
/ r
->buffer_height
* MACROBLOCK_HEIGHT
/ r
->macroblock_size
242 shader
= ureg_create(TGSI_PROCESSOR_VERTEX
);
246 vrect
= ureg_DECL_vs_input(shader
, VS_I_RECT
);
247 vpos
= ureg_DECL_vs_input(shader
, VS_I_VPOS
);
249 t_vpos
= calc_position(r
, shader
, ureg_imm2f(shader
, scale
.x
, scale
.y
));
250 t_vtex
= ureg_DECL_temporary(shader
);
252 o_vpos
= ureg_DECL_output(shader
, TGSI_SEMANTIC_POSITION
, VS_O_VPOS
);
253 o_flags
= ureg_DECL_output(shader
, TGSI_SEMANTIC_GENERIC
, VS_O_FLAGS
);
257 * o_flags.z = intra * 0.5
260 * t_vtex.xy = vrect.y ? { 0, scale.y } : { -scale.y : 0 }
261 * t_vtex.z = vpos.y % 2
262 * t_vtex.y = t_vtex.z ? t_vtex.x : t_vtex.y
263 * o_vpos.y = t_vtex.y + t_vpos.y
265 * o_flags.w = t_vtex.z ? 0 : 1
270 vs_callback(callback_priv
, r
, shader
, VS_O_VTEX
, t_vpos
);
272 ureg_MUL(shader
, ureg_writemask(o_flags
, TGSI_WRITEMASK_Z
),
273 ureg_scalar(vpos
, TGSI_SWIZZLE_Z
), ureg_imm1f(shader
, 0.5f
));
274 ureg_MOV(shader
, ureg_writemask(o_flags
, TGSI_WRITEMASK_W
), ureg_imm1f(shader
, -1.0f
));
276 if (r
->macroblock_size
== MACROBLOCK_HEIGHT
) { //TODO
277 ureg_IF(shader
, ureg_scalar(vpos
, TGSI_SWIZZLE_W
), &label
);
279 ureg_CMP(shader
, ureg_writemask(t_vtex
, TGSI_WRITEMASK_XY
),
280 ureg_negate(ureg_scalar(vrect
, TGSI_SWIZZLE_Y
)),
281 ureg_imm2f(shader
, 0.0f
, scale
.y
),
282 ureg_imm2f(shader
, -scale
.y
, 0.0f
));
283 ureg_MUL(shader
, ureg_writemask(t_vtex
, TGSI_WRITEMASK_Z
),
284 ureg_scalar(vpos
, TGSI_SWIZZLE_Y
), ureg_imm1f(shader
, 0.5f
));
286 ureg_FRC(shader
, ureg_writemask(t_vtex
, TGSI_WRITEMASK_Z
), ureg_src(t_vtex
));
288 ureg_CMP(shader
, ureg_writemask(t_vtex
, TGSI_WRITEMASK_Y
),
289 ureg_negate(ureg_scalar(ureg_src(t_vtex
), TGSI_SWIZZLE_Z
)),
290 ureg_scalar(ureg_src(t_vtex
), TGSI_SWIZZLE_X
),
291 ureg_scalar(ureg_src(t_vtex
), TGSI_SWIZZLE_Y
));
292 ureg_ADD(shader
, ureg_writemask(o_vpos
, TGSI_WRITEMASK_Y
),
293 ureg_src(t_vpos
), ureg_src(t_vtex
));
295 ureg_CMP(shader
, ureg_writemask(o_flags
, TGSI_WRITEMASK_W
),
296 ureg_negate(ureg_scalar(ureg_src(t_vtex
), TGSI_SWIZZLE_Z
)),
297 ureg_imm1f(shader
, 0.0f
), ureg_imm1f(shader
, 1.0f
));
299 ureg_fixup_label(shader
, label
, ureg_get_instruction_number(shader
));
303 ureg_release_temporary(shader
, t_vtex
);
304 ureg_release_temporary(shader
, t_vpos
);
308 return ureg_create_shader_and_destroy(shader
, r
->pipe
);
312 create_ycbcr_frag_shader(struct vl_mc
*r
, float scale
, vl_mc_ycbcr_frag_shader fs_callback
, void *callback_priv
)
314 struct ureg_program
*shader
;
315 struct ureg_src flags
;
317 struct ureg_dst fragment
;
320 shader
= ureg_create(TGSI_PROCESSOR_FRAGMENT
);
324 flags
= ureg_DECL_fs_input(shader
, TGSI_SEMANTIC_GENERIC
, VS_O_FLAGS
, TGSI_INTERPOLATE_LINEAR
);
326 fragment
= ureg_DECL_output(shader
, TGSI_SEMANTIC_COLOR
, 0);
328 tmp
= calc_line(shader
);
334 * fragment.xyz = tex(tc, sampler) * scale + tc.z
339 ureg_SEQ(shader
, ureg_writemask(tmp
, TGSI_WRITEMASK_Y
),
340 ureg_scalar(flags
, TGSI_SWIZZLE_W
), ureg_src(tmp
));
342 ureg_IF(shader
, ureg_scalar(ureg_src(tmp
), TGSI_SWIZZLE_Y
), &label
);
346 ureg_fixup_label(shader
, label
, ureg_get_instruction_number(shader
));
347 ureg_ELSE(shader
, &label
);
349 fs_callback(callback_priv
, r
, shader
, VS_O_VTEX
, tmp
);
352 ureg_MAD(shader
, ureg_writemask(fragment
, TGSI_WRITEMASK_XYZ
),
353 ureg_src(tmp
), ureg_imm1f(shader
, scale
),
354 ureg_scalar(flags
, TGSI_SWIZZLE_Z
));
356 ureg_ADD(shader
, ureg_writemask(fragment
, TGSI_WRITEMASK_XYZ
),
357 ureg_src(tmp
), ureg_scalar(flags
, TGSI_SWIZZLE_Z
));
359 ureg_MOV(shader
, ureg_writemask(fragment
, TGSI_WRITEMASK_W
), ureg_imm1f(shader
, 1.0f
));
361 ureg_fixup_label(shader
, label
, ureg_get_instruction_number(shader
));
364 ureg_release_temporary(shader
, tmp
);
366 return ureg_create_shader_and_destroy(shader
, r
->pipe
);
370 init_pipe_state(struct vl_mc
*r
)
372 struct pipe_sampler_state sampler
;
373 struct pipe_blend_state blend
;
374 struct pipe_rasterizer_state rs_state
;
379 memset(&sampler
, 0, sizeof(sampler
));
380 sampler
.wrap_s
= PIPE_TEX_WRAP_CLAMP_TO_EDGE
;
381 sampler
.wrap_t
= PIPE_TEX_WRAP_CLAMP_TO_EDGE
;
382 sampler
.wrap_r
= PIPE_TEX_WRAP_CLAMP_TO_BORDER
;
383 sampler
.min_img_filter
= PIPE_TEX_FILTER_LINEAR
;
384 sampler
.min_mip_filter
= PIPE_TEX_MIPFILTER_NONE
;
385 sampler
.mag_img_filter
= PIPE_TEX_FILTER_LINEAR
;
386 sampler
.compare_mode
= PIPE_TEX_COMPARE_NONE
;
387 sampler
.compare_func
= PIPE_FUNC_ALWAYS
;
388 sampler
.normalized_coords
= 1;
389 r
->sampler_ref
= r
->pipe
->create_sampler_state(r
->pipe
, &sampler
);
391 goto error_sampler_ref
;
393 for (i
= 0; i
< VL_MC_NUM_BLENDERS
; ++i
) {
394 memset(&blend
, 0, sizeof blend
);
395 blend
.independent_blend_enable
= 0;
396 blend
.rt
[0].blend_enable
= 1;
397 blend
.rt
[0].rgb_func
= PIPE_BLEND_ADD
;
398 blend
.rt
[0].rgb_src_factor
= PIPE_BLENDFACTOR_SRC_ALPHA
;
399 blend
.rt
[0].rgb_dst_factor
= PIPE_BLENDFACTOR_ZERO
;
400 blend
.rt
[0].alpha_func
= PIPE_BLEND_ADD
;
401 blend
.rt
[0].alpha_src_factor
= PIPE_BLENDFACTOR_SRC_ALPHA
;
402 blend
.rt
[0].alpha_dst_factor
= PIPE_BLENDFACTOR_ZERO
;
403 blend
.logicop_enable
= 0;
404 blend
.logicop_func
= PIPE_LOGICOP_CLEAR
;
405 blend
.rt
[0].colormask
= i
;
407 r
->blend_clear
[i
] = r
->pipe
->create_blend_state(r
->pipe
, &blend
);
408 if (!r
->blend_clear
[i
])
411 blend
.rt
[0].rgb_dst_factor
= PIPE_BLENDFACTOR_ONE
;
412 blend
.rt
[0].alpha_dst_factor
= PIPE_BLENDFACTOR_ONE
;
413 r
->blend_add
[i
] = r
->pipe
->create_blend_state(r
->pipe
, &blend
);
414 if (!r
->blend_add
[i
])
418 memset(&rs_state
, 0, sizeof(rs_state
));
419 /*rs_state.sprite_coord_enable */
420 rs_state
.sprite_coord_mode
= PIPE_SPRITE_COORD_UPPER_LEFT
;
421 rs_state
.point_quad_rasterization
= true;
422 rs_state
.point_size
= BLOCK_WIDTH
;
423 rs_state
.gl_rasterization_rules
= true;
424 r
->rs_state
= r
->pipe
->create_rasterizer_state(r
->pipe
, &rs_state
);
432 for (i
= 0; i
< VL_MC_NUM_BLENDERS
; ++i
) {
434 r
->pipe
->delete_blend_state(r
->pipe
, r
->blend_add
[i
]);
436 if (r
->blend_clear
[i
])
437 r
->pipe
->delete_blend_state(r
->pipe
, r
->blend_clear
[i
]);
440 r
->pipe
->delete_sampler_state(r
->pipe
, r
->sampler_ref
);
447 cleanup_pipe_state(struct vl_mc
*r
)
453 r
->pipe
->delete_sampler_state(r
->pipe
, r
->sampler_ref
);
454 for (i
= 0; i
< VL_MC_NUM_BLENDERS
; ++i
) {
455 r
->pipe
->delete_blend_state(r
->pipe
, r
->blend_clear
[i
]);
456 r
->pipe
->delete_blend_state(r
->pipe
, r
->blend_add
[i
]);
458 r
->pipe
->delete_rasterizer_state(r
->pipe
, r
->rs_state
);
462 vl_mc_init(struct vl_mc
*renderer
, struct pipe_context
*pipe
,
463 unsigned buffer_width
, unsigned buffer_height
,
464 unsigned macroblock_size
, float scale
,
465 vl_mc_ycbcr_vert_shader vs_callback
,
466 vl_mc_ycbcr_frag_shader fs_callback
,
472 memset(renderer
, 0, sizeof(struct vl_mc
));
474 renderer
->pipe
= pipe
;
475 renderer
->buffer_width
= buffer_width
;
476 renderer
->buffer_height
= buffer_height
;
477 renderer
->macroblock_size
= macroblock_size
;
479 if (!init_pipe_state(renderer
))
480 goto error_pipe_state
;
482 renderer
->vs_ref
= create_ref_vert_shader(renderer
);
483 if (!renderer
->vs_ref
)
486 renderer
->vs_ycbcr
= create_ycbcr_vert_shader(renderer
, vs_callback
, callback_priv
);
487 if (!renderer
->vs_ycbcr
)
490 renderer
->fs_ref
= create_ref_frag_shader(renderer
);
491 if (!renderer
->fs_ref
)
494 renderer
->fs_ycbcr
= create_ycbcr_frag_shader(renderer
, scale
, fs_callback
, callback_priv
);
495 if (!renderer
->fs_ycbcr
)
501 renderer
->pipe
->delete_fs_state(renderer
->pipe
, renderer
->fs_ref
);
504 renderer
->pipe
->delete_vs_state(renderer
->pipe
, renderer
->vs_ycbcr
);
507 renderer
->pipe
->delete_vs_state(renderer
->pipe
, renderer
->vs_ref
);
510 cleanup_pipe_state(renderer
);
517 vl_mc_cleanup(struct vl_mc
*renderer
)
521 cleanup_pipe_state(renderer
);
523 renderer
->pipe
->delete_vs_state(renderer
->pipe
, renderer
->vs_ref
);
524 renderer
->pipe
->delete_vs_state(renderer
->pipe
, renderer
->vs_ycbcr
);
525 renderer
->pipe
->delete_fs_state(renderer
->pipe
, renderer
->fs_ref
);
526 renderer
->pipe
->delete_fs_state(renderer
->pipe
, renderer
->fs_ycbcr
);
530 vl_mc_init_buffer(struct vl_mc
*renderer
, struct vl_mc_buffer
*buffer
)
532 assert(renderer
&& buffer
);
534 buffer
->renderer
= renderer
;
536 buffer
->viewport
.scale
[2] = 1;
537 buffer
->viewport
.scale
[3] = 1;
538 buffer
->viewport
.translate
[0] = 0;
539 buffer
->viewport
.translate
[1] = 0;
540 buffer
->viewport
.translate
[2] = 0;
541 buffer
->viewport
.translate
[3] = 0;
543 buffer
->fb_state
.nr_cbufs
= 1;
544 buffer
->fb_state
.zsbuf
= NULL
;
550 vl_mc_cleanup_buffer(struct vl_mc_buffer
*buffer
)
556 vl_mc_set_surface(struct vl_mc_buffer
*buffer
, struct pipe_surface
*surface
)
558 assert(buffer
&& surface
);
560 buffer
->surface_cleared
= false;
562 buffer
->viewport
.scale
[0] = surface
->width
;
563 buffer
->viewport
.scale
[1] = surface
->height
;
565 buffer
->fb_state
.width
= surface
->width
;
566 buffer
->fb_state
.height
= surface
->height
;
567 buffer
->fb_state
.cbufs
[0] = surface
;
571 prepare_pipe_4_rendering(struct vl_mc_buffer
*buffer
, unsigned mask
)
573 struct vl_mc
*renderer
;
577 renderer
= buffer
->renderer
;
578 renderer
->pipe
->bind_rasterizer_state(renderer
->pipe
, renderer
->rs_state
);
580 if (buffer
->surface_cleared
)
581 renderer
->pipe
->bind_blend_state(renderer
->pipe
, renderer
->blend_add
[mask
]);
583 renderer
->pipe
->bind_blend_state(renderer
->pipe
, renderer
->blend_clear
[mask
]);
585 renderer
->pipe
->set_framebuffer_state(renderer
->pipe
, &buffer
->fb_state
);
586 renderer
->pipe
->set_viewport_state(renderer
->pipe
, &buffer
->viewport
);
590 vl_mc_render_ref(struct vl_mc_buffer
*buffer
, struct pipe_sampler_view
*ref
)
592 struct vl_mc
*renderer
;
594 assert(buffer
&& ref
);
596 prepare_pipe_4_rendering(buffer
, PIPE_MASK_R
| PIPE_MASK_G
| PIPE_MASK_B
);
598 renderer
= buffer
->renderer
;
600 renderer
->pipe
->bind_vs_state(renderer
->pipe
, renderer
->vs_ref
);
601 renderer
->pipe
->bind_fs_state(renderer
->pipe
, renderer
->fs_ref
);
603 renderer
->pipe
->set_fragment_sampler_views(renderer
->pipe
, 1, &ref
);
604 renderer
->pipe
->bind_fragment_sampler_states(renderer
->pipe
, 1, &renderer
->sampler_ref
);
606 util_draw_arrays_instanced(renderer
->pipe
, PIPE_PRIM_QUADS
, 0, 4, 0,
607 renderer
->buffer_width
/ MACROBLOCK_WIDTH
*
608 renderer
->buffer_height
/ MACROBLOCK_HEIGHT
);
610 buffer
->surface_cleared
= true;
614 vl_mc_render_ycbcr(struct vl_mc_buffer
*buffer
, unsigned component
, unsigned num_instances
)
616 struct vl_mc
*renderer
;
620 if (num_instances
== 0)
623 prepare_pipe_4_rendering(buffer
, 1 << component
);
625 renderer
= buffer
->renderer
;
627 renderer
->pipe
->bind_vs_state(renderer
->pipe
, renderer
->vs_ycbcr
);
628 renderer
->pipe
->bind_fs_state(renderer
->pipe
, renderer
->fs_ycbcr
);
630 util_draw_arrays_instanced(renderer
->pipe
, PIPE_PRIM_QUADS
, 0, 4, 0, num_instances
);