#include <assert.h>
-#include <pipe/p_context.h>
+#include "pipe/p_compiler.h"
+#include "pipe/p_context.h"
-#include <util/u_memory.h>
-#include <util/u_draw.h>
-#include <util/u_surface.h>
+#include "util/u_memory.h"
+#include "util/u_draw.h"
+#include "util/u_surface.h"
-#include <tgsi/tgsi_ureg.h>
+#include "tgsi/tgsi_ureg.h"
#include "vl_csc.h"
#include "vl_types.h"
}
static void *
-create_frag_shader_palette(struct vl_compositor *c)
+create_frag_shader_palette(struct vl_compositor *c, bool include_cc)
{
struct ureg_program *shader;
struct ureg_src csc[3];
tc = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, 1, TGSI_INTERPOLATE_LINEAR);
sampler = ureg_DECL_sampler(shader, 0);
palette = ureg_DECL_sampler(shader, 1);
+
texel = ureg_DECL_temporary(shader);
fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);
* fragment.a = texel.a
*/
ureg_TEX(shader, texel, TGSI_TEXTURE_2D, tc, sampler);
- ureg_MUL(shader, ureg_writemask(texel, TGSI_WRITEMASK_X), ureg_src(texel), ureg_imm1f(shader, 15.0f / 16.0f));
ureg_MOV(shader, ureg_writemask(fragment, TGSI_WRITEMASK_W), ureg_src(texel));
- ureg_TEX(shader, texel, TGSI_TEXTURE_1D, ureg_src(texel), palette);
-
- for (i = 0; i < 3; ++i)
- ureg_DP4(shader, ureg_writemask(fragment, TGSI_WRITEMASK_X << i), csc[i], ureg_src(texel));
+ if (include_cc) {
+ ureg_TEX(shader, texel, TGSI_TEXTURE_1D, ureg_src(texel), palette);
+ for (i = 0; i < 3; ++i)
+ ureg_DP4(shader, ureg_writemask(fragment, TGSI_WRITEMASK_X << i), csc[i], ureg_src(texel));
+ } else {
+ ureg_TEX(shader, ureg_writemask(fragment, TGSI_WRITEMASK_XYZ),
+ TGSI_TEXTURE_1D, ureg_src(texel), palette);
+ }
ureg_release_temporary(shader, texel);
ureg_END(shader);
return false;
}
- c->fs_palette = create_frag_shader_palette(c);
- if (!c->fs_palette) {
- debug_printf("Unable to create Palette-to-RGB fragment shader.\n");
+ c->fs_palette.yuv = create_frag_shader_palette(c, true);
+ if (!c->fs_palette.yuv) {
+ debug_printf("Unable to create YUV-Palette-to-RGB fragment shader.\n");
+ return false;
+ }
+
+ c->fs_palette.rgb = create_frag_shader_palette(c, false);
+ if (!c->fs_palette.rgb) {
+ debug_printf("Unable to create RGB-Palette-to-RGB fragment shader.\n");
return false;
}
c->pipe->delete_vs_state(c->pipe, c->vs);
c->pipe->delete_fs_state(c->pipe, c->fs_video_buffer);
- c->pipe->delete_fs_state(c->pipe, c->fs_palette);
+ c->pipe->delete_fs_state(c->pipe, c->fs_palette.yuv);
+ c->pipe->delete_fs_state(c->pipe, c->fs_palette.rgb);
c->pipe->delete_fs_state(c->pipe, c->fs_rgba);
}
struct pipe_rasterizer_state rast;
struct pipe_sampler_state sampler;
struct pipe_blend_state blend;
+ struct pipe_depth_stencil_alpha_state dsa;
+ unsigned i;
assert(c);
c->viewport.scale[2] = 1;
c->viewport.scale[3] = 1;
- c->viewport.translate[0] = 0;
- c->viewport.translate[1] = 0;
c->viewport.translate[2] = 0;
c->viewport.translate[3] = 0;
memset(&blend, 0, sizeof blend);
blend.independent_blend_enable = 0;
+ blend.rt[0].blend_enable = 0;
+ blend.logicop_enable = 0;
+ blend.logicop_func = PIPE_LOGICOP_CLEAR;
+ blend.rt[0].colormask = PIPE_MASK_RGBA;
+ blend.dither = 0;
+ c->blend_clear = c->pipe->create_blend_state(c->pipe, &blend);
+
blend.rt[0].blend_enable = 1;
blend.rt[0].rgb_func = PIPE_BLEND_ADD;
blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_SRC_ALPHA;
blend.rt[0].alpha_func = PIPE_BLEND_ADD;
blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ONE;
- blend.logicop_enable = 0;
- blend.logicop_func = PIPE_LOGICOP_CLEAR;
- blend.rt[0].colormask = PIPE_MASK_RGBA;
- blend.dither = 0;
- c->blend = c->pipe->create_blend_state(c->pipe, &blend);
+ c->blend_add = c->pipe->create_blend_state(c->pipe, &blend);
memset(&rast, 0, sizeof rast);
rast.flatshade = 1;
c->rast = c->pipe->create_rasterizer_state(c->pipe, &rast);
+ memset(&dsa, 0, sizeof dsa);
+ dsa.depth.enabled = 0;
+ dsa.depth.writemask = 0;
+ dsa.depth.func = PIPE_FUNC_ALWAYS;
+ for (i = 0; i < 2; ++i) {
+ dsa.stencil[i].enabled = 0;
+ dsa.stencil[i].func = PIPE_FUNC_ALWAYS;
+ dsa.stencil[i].fail_op = PIPE_STENCIL_OP_KEEP;
+ dsa.stencil[i].zpass_op = PIPE_STENCIL_OP_KEEP;
+ dsa.stencil[i].zfail_op = PIPE_STENCIL_OP_KEEP;
+ dsa.stencil[i].valuemask = 0;
+ dsa.stencil[i].writemask = 0;
+ }
+ dsa.alpha.enabled = 0;
+ dsa.alpha.func = PIPE_FUNC_ALWAYS;
+ dsa.alpha.ref_value = 0;
+ c->dsa = c->pipe->create_depth_stencil_alpha_state(c->pipe, &dsa);
+ c->pipe->bind_depth_stencil_alpha_state(c->pipe, c->dsa);
return true;
}
{
assert(c);
+ /* Asserted in softpipe_delete_fs_state() for some reason */
+ c->pipe->bind_vs_state(c->pipe, NULL);
+ c->pipe->bind_fs_state(c->pipe, NULL);
+
+ c->pipe->delete_depth_stencil_alpha_state(c->pipe, c->dsa);
c->pipe->delete_sampler_state(c->pipe, c->sampler_linear);
c->pipe->delete_sampler_state(c->pipe, c->sampler_nearest);
- c->pipe->delete_blend_state(c->pipe, c->blend);
+ c->pipe->delete_blend_state(c->pipe, c->blend_clear);
+ c->pipe->delete_blend_state(c->pipe, c->blend_add);
c->pipe->delete_rasterizer_state(c->pipe, c->rast);
}
pipe_resource_reference(&c->csc_matrix, NULL);
}
-static inline struct pipe_video_rect
+static INLINE struct pipe_video_rect
default_rect(struct vl_compositor_layer *layer)
{
struct pipe_resource *res = layer->sampler_views[0]->texture;
return rect;
}
-static inline struct vertex2f
-calc_topleft(struct vertex2f inv_size, struct pipe_video_rect rect)
+static INLINE struct vertex2f
+calc_topleft(struct vertex2f size, struct pipe_video_rect rect)
{
- struct vertex2f res = { rect.x * inv_size.x, rect.y * inv_size.y };
+ struct vertex2f res = { rect.x / size.x, rect.y / size.y };
return res;
}
-static inline struct vertex2f
-calc_bottomright(struct vertex2f inv_size, struct pipe_video_rect rect)
+static INLINE struct vertex2f
+calc_bottomright(struct vertex2f size, struct pipe_video_rect rect)
{
- struct vertex2f res = { (rect.x + rect.w) * inv_size.x, (rect.y + rect.h) * inv_size.y };
+ struct vertex2f res = { (rect.x + rect.w) / size.x, (rect.y + rect.h) / size.y };
return res;
}
-static inline void
+static INLINE void
calc_src_and_dst(struct vl_compositor_layer *layer, unsigned width, unsigned height,
struct pipe_video_rect src, struct pipe_video_rect dst)
{
- struct vertex2f inv_size = { 1.0f / width, 1.0f / height };
+ struct vertex2f size = { width, height };
- layer->src.tl = calc_topleft(inv_size, src);
- layer->src.br = calc_bottomright(inv_size, src);
- layer->dst.tl = calc_topleft(inv_size, dst);
- layer->dst.br = calc_bottomright(inv_size, dst);
+ layer->src.tl = calc_topleft(size, src);
+ layer->src.br = calc_bottomright(size, src);
+ layer->dst.tl = calc_topleft(size, dst);
+ layer->dst.br = calc_bottomright(size, dst);
}
static void
struct pipe_sampler_view **samplers = &layer->sampler_views[0];
unsigned num_sampler_views = !samplers[1] ? 1 : !samplers[2] ? 2 : 3;
+ c->pipe->bind_blend_state(c->pipe, layer->blend);
c->pipe->bind_fs_state(c->pipe, layer->fs);
c->pipe->bind_fragment_sampler_states(c->pipe, num_sampler_views, layer->samplers);
c->pipe->set_fragment_sampler_views(c->pipe, num_sampler_views, samplers);
}
}
-static void
-vl_compositor_reset_dirty_area(struct pipe_video_compositor *compositor)
+void
+vl_compositor_reset_dirty_area(struct vl_compositor *c)
{
- struct vl_compositor *c = (struct vl_compositor *)compositor;
-
- assert(compositor);
+ assert(c);
c->dirty_tl.x = c->dirty_tl.y = 0.0f;
c->dirty_br.x = c->dirty_br.y = 1.0f;
}
-static void
-vl_compositor_set_clear_color(struct pipe_video_compositor *compositor, float color[4])
+void
+vl_compositor_set_clear_color(struct vl_compositor *c, float color[4])
{
- struct vl_compositor *c = (struct vl_compositor *)compositor;
unsigned i;
- assert(compositor);
+ assert(c);
for (i = 0; i < 4; ++i)
c->clear_color[i] = color[i];
}
-static void
-vl_compositor_clear_layers(struct pipe_video_compositor *compositor)
+void
+vl_compositor_clear_layers(struct vl_compositor *c)
{
- struct vl_compositor *c = (struct vl_compositor *)compositor;
unsigned i, j;
- assert(compositor);
+ assert(c);
c->used_layers = 0;
for ( i = 0; i < VL_COMPOSITOR_MAX_LAYERS; ++i) {
+ c->layers[i].clearing = i ? false : true;
+ c->layers[i].blend = i ? c->blend_add : c->blend_clear;
c->layers[i].fs = NULL;
for ( j = 0; j < 3; j++)
pipe_sampler_view_reference(&c->layers[i].sampler_views[j], NULL);
}
}
-static void
-vl_compositor_destroy(struct pipe_video_compositor *compositor)
+void
+vl_compositor_cleanup(struct vl_compositor *c)
{
- struct vl_compositor *c = (struct vl_compositor *)compositor;
- assert(compositor);
+ assert(c);
- vl_compositor_clear_layers(compositor);
+ vl_compositor_clear_layers(c);
cleanup_buffers(c);
cleanup_shaders(c);
cleanup_pipe_state(c);
-
- FREE(compositor);
}
-static void
-vl_compositor_set_csc_matrix(struct pipe_video_compositor *compositor, const float matrix[16])
+void
+vl_compositor_set_csc_matrix(struct vl_compositor *c, const float matrix[16])
{
- struct vl_compositor *c = (struct vl_compositor *)compositor;
struct pipe_transfer *buf_transfer;
- assert(compositor);
+ assert(c);
memcpy
(
pipe_buffer_unmap(c->pipe, buf_transfer);
}
-static void
-vl_compositor_set_buffer_layer(struct pipe_video_compositor *compositor,
+void
+vl_compositor_set_layer_blend(struct vl_compositor *c,
+ unsigned layer, void *blend,
+ bool is_clearing)
+{
+ assert(c && blend);
+
+ assert(layer < VL_COMPOSITOR_MAX_LAYERS);
+
+ c->layers[layer].clearing = is_clearing;
+ c->layers[layer].blend = blend;
+}
+
+void
+vl_compositor_set_buffer_layer(struct vl_compositor *c,
unsigned layer,
struct pipe_video_buffer *buffer,
struct pipe_video_rect *src_rect,
struct pipe_video_rect *dst_rect)
{
- struct vl_compositor *c = (struct vl_compositor *)compositor;
struct pipe_sampler_view **sampler_views;
unsigned i;
- assert(compositor && buffer);
+ assert(c && buffer);
assert(layer < VL_COMPOSITOR_MAX_LAYERS);
c->used_layers |= 1 << layer;
- c->layers[layer].clearing = true;
c->layers[layer].fs = c->fs_video_buffer;
sampler_views = buffer->get_sampler_view_components(buffer);
dst_rect ? *dst_rect : default_rect(&c->layers[layer]));
}
-static void
-vl_compositor_set_palette_layer(struct pipe_video_compositor *compositor,
+void
+vl_compositor_set_palette_layer(struct vl_compositor *c,
unsigned layer,
struct pipe_sampler_view *indexes,
struct pipe_sampler_view *palette,
struct pipe_video_rect *src_rect,
- struct pipe_video_rect *dst_rect)
+ struct pipe_video_rect *dst_rect,
+ bool include_color_conversion)
{
- struct vl_compositor *c = (struct vl_compositor *)compositor;
- assert(compositor && indexes && palette);
+ assert(c && indexes && palette);
assert(layer < VL_COMPOSITOR_MAX_LAYERS);
c->used_layers |= 1 << layer;
- c->layers[layer].clearing = false;
- c->layers[layer].fs = c->fs_palette;
+
+ c->layers[layer].fs = include_color_conversion ?
+ c->fs_palette.yuv : c->fs_palette.rgb;
+
c->layers[layer].samplers[0] = c->sampler_linear;
c->layers[layer].samplers[1] = c->sampler_nearest;
c->layers[layer].samplers[2] = NULL;
}
-static void
-vl_compositor_set_rgba_layer(struct pipe_video_compositor *compositor,
+void
+vl_compositor_set_rgba_layer(struct vl_compositor *c,
unsigned layer,
struct pipe_sampler_view *rgba,
struct pipe_video_rect *src_rect,
struct pipe_video_rect *dst_rect)
{
- struct vl_compositor *c = (struct vl_compositor *)compositor;
- assert(compositor && rgba);
+ assert(c && rgba);
assert(layer < VL_COMPOSITOR_MAX_LAYERS);
c->used_layers |= 1 << layer;
- c->layers[layer].clearing = false;
c->layers[layer].fs = c->fs_rgba;
c->layers[layer].samplers[0] = c->sampler_linear;
c->layers[layer].samplers[1] = NULL;
dst_rect ? *dst_rect : default_rect(&c->layers[layer]));
}
-static void
-vl_compositor_render(struct pipe_video_compositor *compositor,
- enum pipe_mpeg12_picture_type picture_type,
+void
+vl_compositor_render(struct vl_compositor *c,
struct pipe_surface *dst_surface,
struct pipe_video_rect *dst_area,
- struct pipe_fence_handle **fence)
+ struct pipe_video_rect *dst_clip,
+ bool clear_dirty_area)
{
- struct vl_compositor *c = (struct vl_compositor *)compositor;
struct pipe_scissor_state scissor;
- assert(compositor);
+ assert(c);
assert(dst_surface);
c->fb_state.width = dst_surface->width;
c->fb_state.height = dst_surface->height;
c->fb_state.cbufs[0] = dst_surface;
-
- c->viewport.scale[0] = dst_surface->width;
- c->viewport.scale[1] = dst_surface->height;
-
+
if (dst_area) {
- scissor.minx = dst_area->x;
- scissor.miny = dst_area->y;
- scissor.maxx = dst_area->x + dst_area->w;
- scissor.maxy = dst_area->y + dst_area->h;
+ c->viewport.scale[0] = dst_area->w;
+ c->viewport.scale[1] = dst_area->h;
+ c->viewport.translate[0] = dst_area->x;
+ c->viewport.translate[1] = dst_area->y;
+ } else {
+ c->viewport.scale[0] = dst_surface->width;
+ c->viewport.scale[1] = dst_surface->height;
+ c->viewport.translate[0] = 0;
+ c->viewport.translate[1] = 0;
+ }
+
+ if (dst_clip) {
+ scissor.minx = dst_clip->x;
+ scissor.miny = dst_clip->y;
+ scissor.maxx = dst_clip->x + dst_clip->w;
+ scissor.maxy = dst_clip->y + dst_clip->h;
} else {
scissor.minx = 0;
scissor.miny = 0;
gen_vertex_data(c);
- if (c->dirty_tl.x < c->dirty_br.x || c->dirty_tl.y < c->dirty_br.y) {
- util_clear_render_target(c->pipe, dst_surface, c->clear_color, 0, 0, dst_surface->width, dst_surface->height);
+ if (clear_dirty_area && (c->dirty_tl.x < c->dirty_br.x ||
+ c->dirty_tl.y < c->dirty_br.y)) {
+ util_clear_render_target(c->pipe, dst_surface, c->clear_color,
+ 0, 0, dst_surface->width, dst_surface->height);
c->dirty_tl.x = c->dirty_tl.y = 1.0f;
c->dirty_br.x = c->dirty_br.y = 0.0f;
}
c->pipe->set_vertex_buffers(c->pipe, 1, &c->vertex_buf);
c->pipe->bind_vertex_elements_state(c->pipe, c->vertex_elems_state);
c->pipe->set_constant_buffer(c->pipe, PIPE_SHADER_FRAGMENT, 0, c->csc_matrix);
- c->pipe->bind_blend_state(c->pipe, c->blend);
c->pipe->bind_rasterizer_state(c->pipe, c->rast);
draw_layers(c);
-
- c->pipe->flush(c->pipe, fence);
}
-struct pipe_video_compositor *
-vl_compositor_init(struct pipe_video_context *vpipe, struct pipe_context *pipe)
+bool
+vl_compositor_init(struct vl_compositor *c, struct pipe_context *pipe)
{
csc_matrix csc_matrix;
- struct vl_compositor *compositor;
- compositor = CALLOC_STRUCT(vl_compositor);
+ c->pipe = pipe;
- compositor->base.context = vpipe;
- compositor->base.destroy = vl_compositor_destroy;
- compositor->base.set_csc_matrix = vl_compositor_set_csc_matrix;
- compositor->base.reset_dirty_area = vl_compositor_reset_dirty_area;
- compositor->base.set_clear_color = vl_compositor_set_clear_color;
- compositor->base.clear_layers = vl_compositor_clear_layers;
- compositor->base.set_buffer_layer = vl_compositor_set_buffer_layer;
- compositor->base.set_palette_layer = vl_compositor_set_palette_layer;
- compositor->base.set_rgba_layer = vl_compositor_set_rgba_layer;
- compositor->base.render_picture = vl_compositor_render;
-
- compositor->pipe = pipe;
-
- if (!init_pipe_state(compositor))
+ if (!init_pipe_state(c))
return false;
- if (!init_shaders(compositor)) {
- cleanup_pipe_state(compositor);
+ if (!init_shaders(c)) {
+ cleanup_pipe_state(c);
return false;
}
- if (!init_buffers(compositor)) {
- cleanup_shaders(compositor);
- cleanup_pipe_state(compositor);
+ if (!init_buffers(c)) {
+ cleanup_shaders(c);
+ cleanup_pipe_state(c);
return false;
}
- vl_compositor_clear_layers(&compositor->base);
+ vl_compositor_clear_layers(c);
vl_csc_get_matrix(VL_CSC_COLOR_STANDARD_IDENTITY, NULL, true, csc_matrix);
- vl_compositor_set_csc_matrix(&compositor->base, csc_matrix);
+ vl_compositor_set_csc_matrix(c, csc_matrix);
- compositor->clear_color[0] = compositor->clear_color[1] = 0.0f;
- compositor->clear_color[2] = compositor->clear_color[3] = 0.0f;
- vl_compositor_reset_dirty_area(&compositor->base);
+ c->clear_color[0] = c->clear_color[1] = 0.0f;
+ c->clear_color[2] = c->clear_color[3] = 0.0f;
+ vl_compositor_reset_dirty_area(c);
- return &compositor->base;
+ return true;
}
projects / mesa.git / blobdiff