AlexIndustrial/mesa
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[g3dvl] move compositor creation and handling directly into the state trackers

Browse Source
This commit is contained in:
Christian König
2011-07-08 14:44:19 +02:00
parent 10fd45114d
commit bd5fd67a3e
11 changed files with 164 additions and 200 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/gallium/auxiliary/vl/vl_compositor.c
+43 -69
View File
@@ -500,36 +500,32 @@ draw_layers(struct vl_compositor *c)
}
}
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) {
@@ -539,28 +535,24 @@ vl_compositor_clear_layers(struct pipe_video_compositor *compositor)
}
}
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
(
@@ -574,18 +566,17 @@ vl_compositor_set_csc_matrix(struct pipe_video_compositor *compositor, const flo
pipe_buffer_unmap(c->pipe, buf_transfer);
}
static void
vl_compositor_set_buffer_layer(struct pipe_video_compositor *compositor,
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);
@@ -604,16 +595,15 @@ vl_compositor_set_buffer_layer(struct pipe_video_compositor *compositor,
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 vl_compositor *c = (struct vl_compositor *)compositor;
assert(compositor && indexes && palette);
assert(c && indexes && palette);
assert(layer < VL_COMPOSITOR_MAX_LAYERS);
@@ -632,15 +622,14 @@ vl_compositor_set_palette_layer(struct pipe_video_compositor *compositor,
}
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);
@@ -658,17 +647,16 @@ vl_compositor_set_rgba_layer(struct pipe_video_compositor *compositor,
dst_rect ? *dst_rect : default_rect(&c->layers[layer]));
}
static void
vl_compositor_render(struct pipe_video_compositor *compositor,
void
vl_compositor_render(struct vl_compositor *c,
enum pipe_mpeg12_picture_type picture_type,
struct pipe_surface *dst_surface,
struct pipe_video_rect *dst_area,
struct pipe_fence_handle **fence)
{
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;
@@ -713,48 +701,34 @@ vl_compositor_render(struct pipe_video_compositor *compositor,
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;
}
src/gallium/auxiliary/vl/vl_compositor.h
+87 -3
View File
@@ -36,6 +36,10 @@
struct pipe_context;
/**
* composing and displaying of image data
*/
#define VL_COMPOSITOR_MAX_LAYERS 16
struct vl_compositor_layer
@@ -53,7 +57,6 @@ struct vl_compositor_layer
struct vl_compositor
{
struct pipe_video_compositor base;
struct pipe_context *pipe;
struct pipe_framebuffer_state fb_state;
@@ -79,7 +82,88 @@ struct vl_compositor
struct vl_compositor_layer layers[VL_COMPOSITOR_MAX_LAYERS];
};
struct pipe_video_compositor *vl_compositor_init(struct pipe_video_context *vpipe,
struct pipe_context *pipe);
/**
* initialize this compositor
*/
bool
vl_compositor_init(struct vl_compositor *compositor, struct pipe_context *pipe);
/**
* set yuv -> rgba conversion matrix
*/
void
vl_compositor_set_csc_matrix(struct vl_compositor *compositor, const float mat[16]);
/**
* reset dirty area, so it's cleared with the clear colour
*/
void
vl_compositor_reset_dirty_area(struct vl_compositor *compositor);
/**
* set the clear color
*/
void
vl_compositor_set_clear_color(struct vl_compositor *compositor, float color[4]);
/**
* set overlay samplers
*/
/*@{*/
/**
* reset all currently set layers
*/
void
vl_compositor_clear_layers(struct vl_compositor *compositor);
/**
* set a video buffer as a layer to render
*/
void
vl_compositor_set_buffer_layer(struct vl_compositor *compositor,
unsigned layer,
struct pipe_video_buffer *buffer,
struct pipe_video_rect *src_rect,
struct pipe_video_rect *dst_rect);
/**
* set a paletted sampler as a layer to render
*/
void
vl_compositor_set_palette_layer(struct vl_compositor *compositor,
unsigned layer,
struct pipe_sampler_view *indexes,
struct pipe_sampler_view *palette,
struct pipe_video_rect *src_rect,
struct pipe_video_rect *dst_rect);
/**
* set a rgba sampler as a layer to render
*/
void
vl_compositor_set_rgba_layer(struct vl_compositor *compositor,
unsigned layer,
struct pipe_sampler_view *rgba,
struct pipe_video_rect *src_rect,
struct pipe_video_rect *dst_rect);
/*@}*/
/**
* render the layers to the frontbuffer
*/
void
vl_compositor_render(struct vl_compositor *compositor,
enum pipe_mpeg12_picture_type picture_type,
struct pipe_surface *dst_surface,
struct pipe_video_rect *dst_area,
struct pipe_fence_handle **fence);
/**
* destroy this compositor
*/
void
vl_compositor_cleanup(struct vl_compositor *compositor);
#endif /* vl_compositor_h */
src/gallium/auxiliary/vl/vl_context.c
-11
View File
@@ -114,16 +114,6 @@ vl_context_create_buffer(struct pipe_video_context *context,
return result;
}
static struct pipe_video_compositor *
vl_context_create_compositor(struct pipe_video_context *context)
{
struct vl_context *ctx = (struct vl_context*)context;
assert(context);
return vl_compositor_init(context, ctx->pipe);
}
struct pipe_video_context *
vl_create_context(struct pipe_context *pipe)
{
@@ -139,7 +129,6 @@ vl_create_context(struct pipe_context *pipe)
ctx->base.destroy = vl_context_destroy;
ctx->base.create_decoder = vl_context_create_decoder;
ctx->base.create_buffer = vl_context_create_buffer;
ctx->base.create_compositor = vl_context_create_compositor;
ctx->pipe = pipe;
src/gallium/include/pipe/p_video_context.h
-83
View File
@@ -71,11 +71,6 @@ struct pipe_video_context
enum pipe_format buffer_format,
enum pipe_video_chroma_format chroma_format,
unsigned width, unsigned height);
/**
* Creates a video compositor
*/
struct pipe_video_compositor *(*create_compositor)(struct pipe_video_context *context);
};
/**
@@ -201,84 +196,6 @@ struct pipe_video_buffer
struct pipe_surface **(*get_surfaces)(struct pipe_video_buffer *buffer);
};
/**
* composing and displaying of image data
*/
struct pipe_video_compositor
{
struct pipe_video_context *context;
/**
* destroy this compositor
*/
void (*destroy)(struct pipe_video_compositor *compositor);
/**
* set yuv -> rgba conversion matrix
*/
void (*set_csc_matrix)(struct pipe_video_compositor *compositor, const float mat[16]);
/**
* reset dirty area, so it's cleared with the clear colour
*/
void (*reset_dirty_area)(struct pipe_video_compositor *compositor);
/**
* set the clear color
*/
void (*set_clear_color)(struct pipe_video_compositor *compositor, float color[4]);
/**
* set overlay samplers
*/
/*@{*/
/**
* reset all currently set layers
*/
void (*clear_layers)(struct pipe_video_compositor *compositor);
/**
* set a video buffer as a layer to render
*/
void (*set_buffer_layer)(struct pipe_video_compositor *compositor,
unsigned layer,
struct pipe_video_buffer *buffer,
struct pipe_video_rect *src_rect,
struct pipe_video_rect *dst_rect);
/**
* set a paletted sampler as a layer to render
*/
void (*set_palette_layer)(struct pipe_video_compositor *compositor,
unsigned layer,
struct pipe_sampler_view *indexes,
struct pipe_sampler_view *palette,
struct pipe_video_rect *src_rect,
struct pipe_video_rect *dst_rect);
/**
* set a rgba sampler as a layer to render
*/
void (*set_rgba_layer)(struct pipe_video_compositor *compositor,
unsigned layer,
struct pipe_sampler_view *rgba,
struct pipe_video_rect *src_rect,
struct pipe_video_rect *dst_rect);
/*@}*/
/**
* render the layers to the frontbuffer
*/
void (*render_picture)(struct pipe_video_compositor *compositor,
enum pipe_mpeg12_picture_type picture_type,
struct pipe_surface *dst_surface,
struct pipe_video_rect *dst_area,
struct pipe_fence_handle **fence);
};
#ifdef __cplusplus
}
#endif
src/gallium/state_trackers/vdpau/mixer.c
+7 -7
View File
@@ -61,7 +61,7 @@ vlVdpVideoMixerCreate(VdpDevice device,
return VDP_STATUS_RESOURCES;
vmixer->device = dev;
vmixer->compositor = context->create_compositor(context);
vl_compositor_init(&vmixer->compositor, dev->context->pipe);
vl_csc_get_matrix
(
@@ -69,7 +69,7 @@ vlVdpVideoMixerCreate(VdpDevice device,
VL_CSC_COLOR_STANDARD_IDENTITY : VL_CSC_COLOR_STANDARD_BT_601,
NULL, true, csc
);
vmixer->compositor->set_csc_matrix(vmixer->compositor, csc);
vl_compositor_set_csc_matrix(&vmixer->compositor, csc);
/*
* TODO: Handle features and parameters
@@ -97,7 +97,7 @@ vlVdpVideoMixerDestroy(VdpVideoMixer mixer)
if (!vmixer)
return VDP_STATUS_INVALID_HANDLE;
vmixer->compositor->destroy(vmixer->compositor);
vl_compositor_cleanup(&vmixer->compositor);
FREE(vmixer);
@@ -158,10 +158,10 @@ VdpStatus vlVdpVideoMixerRender(VdpVideoMixer mixer,
if (!dst)
return VDP_STATUS_INVALID_HANDLE;
vmixer->compositor->clear_layers(vmixer->compositor);
vmixer->compositor->set_buffer_layer(vmixer->compositor, 0, surf->video_buffer, NULL, NULL);
vmixer->compositor->render_picture(vmixer->compositor, PIPE_MPEG12_PICTURE_TYPE_FRAME,
dst->surface, NULL, NULL);
vl_compositor_clear_layers(&vmixer->compositor);
vl_compositor_set_buffer_layer(&vmixer->compositor, 0, surf->video_buffer, NULL, NULL);
vl_compositor_render(&vmixer->compositor, PIPE_MPEG12_PICTURE_TYPE_FRAME,
dst->surface, NULL, NULL);
return VDP_STATUS_OK;
}
src/gallium/state_trackers/vdpau/presentation.c
+8 -8
View File
@@ -67,8 +67,8 @@ vlVdpPresentationQueueCreate(VdpDevice device,
pq->device = dev;
pq->drawable = pqt->drawable;
pq->compositor = context->create_compositor(context);
if (!pq->compositor) {
if (!vl_compositor_init(&pq->compositor, dev->context->pipe)) {
ret = VDP_STATUS_ERROR;
goto no_compositor;
}
@@ -97,7 +97,7 @@ vlVdpPresentationQueueDestroy(VdpPresentationQueue presentation_queue)
if (!pq)
return VDP_STATUS_INVALID_HANDLE;
pq->compositor->destroy(pq->compositor);
vl_compositor_cleanup(&pq->compositor);
vlRemoveDataHTAB(presentation_queue);
FREE(pq);
@@ -120,7 +120,7 @@ vlVdpPresentationQueueSetBackgroundColor(VdpPresentationQueue presentation_queue
if (!pq)
return VDP_STATUS_INVALID_HANDLE;
pq->compositor->set_clear_color(pq->compositor, (float*)background_color);
vl_compositor_set_clear_color(&pq->compositor, (float*)background_color);
return VDP_STATUS_OK;
}
@@ -170,10 +170,10 @@ vlVdpPresentationQueueDisplay(VdpPresentationQueue presentation_queue,
if (!surf)
return VDP_STATUS_INVALID_HANDLE;
pq->compositor->clear_layers(pq->compositor);
pq->compositor->set_rgba_layer(pq->compositor, 0, surf->sampler_view, NULL, NULL);
pq->compositor->render_picture(pq->compositor, PIPE_MPEG12_PICTURE_TYPE_FRAME,
drawable_surface, NULL, NULL);
vl_compositor_clear_layers(&pq->compositor);
vl_compositor_set_rgba_layer(&pq->compositor, 0, surf->sampler_view, NULL, NULL);
vl_compositor_render(&pq->compositor, PIPE_MPEG12_PICTURE_TYPE_FRAME,
drawable_surface, NULL, NULL);
pq->device->context->vpipe->screen->flush_frontbuffer
(
src/gallium/state_trackers/vdpau/vdpau_private.h
+3 -2
View File
@@ -37,6 +37,7 @@
#include <pipe/p_video_context.h>
#include <util/u_debug.h>
#include <vl/vl_compositor.h>
#include <vl_winsys.h>
@@ -188,13 +189,13 @@ typedef struct
{
vlVdpDevice *device;
Drawable drawable;
struct pipe_video_compositor *compositor;
struct vl_compositor compositor;
} vlVdpPresentationQueue;
typedef struct
{
vlVdpDevice *device;
struct pipe_video_compositor *compositor;
struct vl_compositor compositor;
} vlVdpVideoMixer;
typedef struct
src/gallium/state_trackers/xorg/xvmc/attributes.c
+1 -1
View File
@@ -113,7 +113,7 @@ Status XvMCSetAttribute(Display *dpy, XvMCContext *context, Atom attribute, int
context_priv->color_standard,
&context_priv->procamp, true, csc
);
context_priv->compositor->set_csc_matrix(context_priv->compositor, csc);
vl_compositor_set_csc_matrix(&context_priv->compositor, csc);
XVMC_MSG(XVMC_TRACE, "[XvMC] Set attribute %s to value %d.\n", attr, value);
src/gallium/state_trackers/xorg/xvmc/context.c
+3 -4
View File
@@ -260,8 +260,7 @@ Status XvMCCreateContext(Display *dpy, XvPortID port, int surface_type_id,
return BadAlloc;
}
context_priv->compositor = vctx->vpipe->create_compositor(vctx->vpipe);
if (!context_priv->compositor) {
if (!vl_compositor_init(&context_priv->compositor, vctx->pipe)) {
XVMC_MSG(XVMC_ERR, "[XvMC] Could not create VL compositor.\n");
context_priv->decoder->destroy(context_priv->decoder);
vl_video_destroy(vctx);
@@ -280,7 +279,7 @@ Status XvMCCreateContext(Display *dpy, XvPortID port, int surface_type_id,
context_priv->color_standard,
&context_priv->procamp, true, csc
);
context_priv->compositor->set_csc_matrix(context_priv->compositor, csc);
vl_compositor_set_csc_matrix(&context_priv->compositor, csc);
context_priv->vctx = vctx;
context_priv->subpicture_max_width = subpic_max_w;
@@ -320,7 +319,7 @@ Status XvMCDestroyContext(Display *dpy, XvMCContext *context)
vscreen = vctx->vscreen;
pipe_surface_reference(&context_priv->drawable_surface, NULL);
context_priv->decoder->destroy(context_priv->decoder);
context_priv->compositor->destroy(context_priv->compositor);
vl_compositor_cleanup(&context_priv->compositor);
vl_video_destroy(vctx);
vl_screen_destroy(vscreen);
FREE(context_priv);
src/gallium/state_trackers/xorg/xvmc/surface.c
+10 -10
View File
@@ -493,7 +493,7 @@ Status XvMCPutSurface(Display *dpy, XvMCSurface *surface, Drawable drawable,
static int dump_window = -1;
struct pipe_video_context *vpipe;
struct pipe_video_compositor *compositor;
struct vl_compositor *compositor;
XvMCSurfacePrivate *surface_priv;
XvMCContextPrivate *context_priv;
@@ -519,7 +519,7 @@ Status XvMCPutSurface(Display *dpy, XvMCSurface *surface, Drawable drawable,
subpicture_priv = surface_priv->subpicture ? surface_priv->subpicture->privData : NULL;
vpipe = context_priv->vctx->vpipe;
compositor = context_priv->compositor;
compositor = &context_priv->compositor;
if (!context_priv->drawable_surface ||
context_priv->dst_rect.x != dst_rect.x || context_priv->dst_rect.y != dst_rect.y ||
@@ -527,7 +527,7 @@ Status XvMCPutSurface(Display *dpy, XvMCSurface *surface, Drawable drawable,
context_priv->drawable_surface = vl_drawable_surface_get(context_priv->vctx, drawable);
context_priv->dst_rect = dst_rect;
compositor->reset_dirty_area(compositor);
vl_compositor_reset_dirty_area(compositor);
}
if (!context_priv->drawable_surface)
@@ -547,8 +547,8 @@ Status XvMCPutSurface(Display *dpy, XvMCSurface *surface, Drawable drawable,
unmap_and_flush_surface(surface_priv);
compositor->clear_layers(compositor);
compositor->set_buffer_layer(compositor, 0, surface_priv->video_buffer, &src_rect, NULL);
vl_compositor_clear_layers(compositor);
vl_compositor_set_buffer_layer(compositor, 0, surface_priv->video_buffer, &src_rect, NULL);
if (subpicture_priv) {
XVMC_MSG(XVMC_TRACE, "[XvMC] Surface %p has subpicture %p.\n", surface, surface_priv->subpicture);
@@ -556,11 +556,11 @@ Status XvMCPutSurface(Display *dpy, XvMCSurface *surface, Drawable drawable,
assert(subpicture_priv->surface == surface);
if (subpicture_priv->palette)
compositor->set_palette_layer(compositor, 1, subpicture_priv->sampler, subpicture_priv->palette,
&subpicture_priv->src_rect, &subpicture_priv->dst_rect);
vl_compositor_set_palette_layer(compositor, 1, subpicture_priv->sampler, subpicture_priv->palette,
&subpicture_priv->src_rect, &subpicture_priv->dst_rect);
else
compositor->set_rgba_layer(compositor, 1, subpicture_priv->sampler,
&subpicture_priv->src_rect, &subpicture_priv->dst_rect);
vl_compositor_set_rgba_layer(compositor, 1, subpicture_priv->sampler,
&subpicture_priv->src_rect, &subpicture_priv->dst_rect);
surface_priv->subpicture = NULL;
subpicture_priv->surface = NULL;
@@ -569,7 +569,7 @@ Status XvMCPutSurface(Display *dpy, XvMCSurface *surface, Drawable drawable,
// Workaround for r600g, there seems to be a bug in the fence refcounting code
vpipe->screen->fence_reference(vpipe->screen, &surface_priv->fence, NULL);
compositor->render_picture(compositor, PictureToPipe(flags), context_priv->drawable_surface, &dst_rect, &surface_priv->fence);
vl_compositor_render(compositor, PictureToPipe(flags), context_priv->drawable_surface, &dst_rect, &surface_priv->fence);
XVMC_MSG(XVMC_TRACE, "[XvMC] Submitted surface %p for display. Pushing to front buffer.\n", surface);
src/gallium/state_trackers/xorg/xvmc/xvmc_private.h
+2 -2
View File
@@ -37,6 +37,7 @@
#include <util/u_math.h>
#include <vl/vl_csc.h>
#include <vl/vl_compositor.h>
#define BLOCK_SIZE_SAMPLES 64
#define BLOCK_SIZE_BYTES (BLOCK_SIZE_SAMPLES * 2)
@@ -44,7 +45,6 @@
struct vl_context;
struct pipe_video_decoder;
struct pipe_video_compositor;
struct pipe_video_decode_buffer;
struct pipe_video_buffer;
@@ -55,10 +55,10 @@ typedef struct
{
struct vl_context *vctx;
struct pipe_video_decoder *decoder;
struct pipe_video_compositor *compositor;
enum VL_CSC_COLOR_STANDARD color_standard;
struct vl_procamp procamp;
struct vl_compositor compositor;
unsigned short subpicture_max_width;
unsigned short subpicture_max_height;