1 /**************************************************************************
2 *
3 * Copyright 2015 Advanced Micro Devices, Inc.
4 * All Rights Reserved.
5 *
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:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
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 THE COPYRIGHT HOLDER(S) OR AUTHOR(S) 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.
25 *
26 **************************************************************************/
27
28 #include "util/u_handle_table.h"
29 #include "util/u_memory.h"
30 #include "util/u_compute.h"
31
32 #include "vl/vl_defines.h"
33 #include "vl/vl_video_buffer.h"
34 #include "vl/vl_deint_filter.h"
35
36 #include "va_private.h"
37
38 static const VARectangle *
vlVaRegionDefault(const VARectangle * region,vlVaSurface * surf,VARectangle * def)39 vlVaRegionDefault(const VARectangle *region, vlVaSurface *surf,
40 VARectangle *def)
41 {
42 if (region)
43 return region;
44
45 def->x = 0;
46 def->y = 0;
47 def->width = surf->templat.width;
48 def->height = surf->templat.height;
49
50 return def;
51 }
52
53 static VAStatus
vlVaPostProcCompositor(vlVaDriver * drv,vlVaContext * context,const VARectangle * src_region,const VARectangle * dst_region,struct pipe_video_buffer * src,struct pipe_video_buffer * dst,enum vl_compositor_deinterlace deinterlace)54 vlVaPostProcCompositor(vlVaDriver *drv, vlVaContext *context,
55 const VARectangle *src_region,
56 const VARectangle *dst_region,
57 struct pipe_video_buffer *src,
58 struct pipe_video_buffer *dst,
59 enum vl_compositor_deinterlace deinterlace)
60 {
61 struct pipe_surface **surfaces;
62 struct u_rect src_rect;
63 struct u_rect dst_rect;
64
65 surfaces = dst->get_surfaces(dst);
66 if (!surfaces || !surfaces[0])
67 return VA_STATUS_ERROR_INVALID_SURFACE;
68
69 src_rect.x0 = src_region->x;
70 src_rect.y0 = src_region->y;
71 src_rect.x1 = src_region->x + src_region->width;
72 src_rect.y1 = src_region->y + src_region->height;
73
74 dst_rect.x0 = dst_region->x;
75 dst_rect.y0 = dst_region->y;
76 dst_rect.x1 = dst_region->x + dst_region->width;
77 dst_rect.y1 = dst_region->y + dst_region->height;
78
79 vl_compositor_clear_layers(&drv->cstate);
80 vl_compositor_set_buffer_layer(&drv->cstate, &drv->compositor, 0, src,
81 &src_rect, NULL, deinterlace);
82 vl_compositor_set_layer_dst_area(&drv->cstate, 0, &dst_rect);
83 vl_compositor_render(&drv->cstate, &drv->compositor, surfaces[0], NULL, false);
84
85 drv->pipe->flush(drv->pipe, NULL, 0);
86 return VA_STATUS_SUCCESS;
87 }
88
vlVaGetBox(struct pipe_video_buffer * buf,unsigned idx,struct pipe_box * box,const VARectangle * region)89 static void vlVaGetBox(struct pipe_video_buffer *buf, unsigned idx,
90 struct pipe_box *box, const VARectangle *region)
91 {
92 unsigned plane = buf->interlaced ? idx / 2: idx;
93 unsigned x, y, width, height;
94
95 x = abs(region->x);
96 y = abs(region->y);
97 width = region->width;
98 height = region->height;
99
100 vl_video_buffer_adjust_size(&x, &y, plane,
101 pipe_format_to_chroma_format(buf->buffer_format),
102 buf->interlaced);
103 vl_video_buffer_adjust_size(&width, &height, plane,
104 pipe_format_to_chroma_format(buf->buffer_format),
105 buf->interlaced);
106
107 box->x = region->x < 0 ? -x : x;
108 box->y = region->y < 0 ? -y : y;
109 box->width = width;
110 box->height = height;
111 }
112
vlVaPostProcBlit(vlVaDriver * drv,vlVaContext * context,const VARectangle * src_region,const VARectangle * dst_region,struct pipe_video_buffer * src,struct pipe_video_buffer * dst,enum vl_compositor_deinterlace deinterlace)113 static VAStatus vlVaPostProcBlit(vlVaDriver *drv, vlVaContext *context,
114 const VARectangle *src_region,
115 const VARectangle *dst_region,
116 struct pipe_video_buffer *src,
117 struct pipe_video_buffer *dst,
118 enum vl_compositor_deinterlace deinterlace)
119 {
120 struct pipe_surface **src_surfaces;
121 struct pipe_surface **dst_surfaces;
122 struct u_rect src_rect;
123 struct u_rect dst_rect;
124 bool scale = false;
125 bool grab = false;
126 unsigned i;
127
128 if ((src->buffer_format == PIPE_FORMAT_B8G8R8A8_UNORM ||
129 src->buffer_format == PIPE_FORMAT_B8G8R8X8_UNORM) &&
130 !src->interlaced)
131 grab = true;
132
133 if ((src->width != dst->width || src->height != dst->height) &&
134 (src->interlaced && dst->interlaced))
135 scale = true;
136
137 src_surfaces = src->get_surfaces(src);
138 if (!src_surfaces || !src_surfaces[0])
139 return VA_STATUS_ERROR_INVALID_SURFACE;
140
141 if (scale || (src->interlaced != dst->interlaced && dst->interlaced)) {
142 vlVaSurface *surf;
143
144 surf = handle_table_get(drv->htab, context->target_id);
145 surf->templat.interlaced = false;
146 dst->destroy(dst);
147
148 if (vlVaHandleSurfaceAllocate(drv, surf, &surf->templat) != VA_STATUS_SUCCESS)
149 return VA_STATUS_ERROR_ALLOCATION_FAILED;
150
151 dst = context->target = surf->buffer;
152 }
153
154 dst_surfaces = dst->get_surfaces(dst);
155 if (!dst_surfaces || !dst_surfaces[0])
156 return VA_STATUS_ERROR_INVALID_SURFACE;
157
158 src_rect.x0 = src_region->x;
159 src_rect.y0 = src_region->y;
160 src_rect.x1 = src_region->x + src_region->width;
161 src_rect.y1 = src_region->y + src_region->height;
162
163 dst_rect.x0 = dst_region->x;
164 dst_rect.y0 = dst_region->y;
165 dst_rect.x1 = dst_region->x + dst_region->width;
166 dst_rect.y1 = dst_region->y + dst_region->height;
167
168 if (grab) {
169 vl_compositor_convert_rgb_to_yuv(&drv->cstate, &drv->compositor, 0,
170 ((struct vl_video_buffer *)src)->resources[0],
171 dst, &src_rect, &dst_rect);
172
173 return VA_STATUS_SUCCESS;
174 }
175
176 if (src->interlaced != dst->interlaced) {
177 vl_compositor_yuv_deint_full(&drv->cstate, &drv->compositor,
178 src, dst, &src_rect, &dst_rect,
179 deinterlace);
180
181 return VA_STATUS_SUCCESS;
182 }
183
184 for (i = 0; i < VL_MAX_SURFACES; ++i) {
185 struct pipe_surface *from = src_surfaces[i];
186 struct pipe_blit_info blit;
187
188 if (src->interlaced) {
189 /* Not 100% accurate, but close enough */
190 switch (deinterlace) {
191 case VL_COMPOSITOR_BOB_TOP:
192 from = src_surfaces[i & ~1];
193 break;
194 case VL_COMPOSITOR_BOB_BOTTOM:
195 from = src_surfaces[(i & ~1) + 1];
196 break;
197 default:
198 break;
199 }
200 }
201
202 if (!from || !dst_surfaces[i])
203 continue;
204
205 memset(&blit, 0, sizeof(blit));
206 blit.src.resource = from->texture;
207 blit.src.format = from->format;
208 blit.src.level = 0;
209 blit.src.box.z = from->u.tex.first_layer;
210 blit.src.box.depth = 1;
211 vlVaGetBox(src, i, &blit.src.box, src_region);
212
213 blit.dst.resource = dst_surfaces[i]->texture;
214 blit.dst.format = dst_surfaces[i]->format;
215 blit.dst.level = 0;
216 blit.dst.box.z = dst_surfaces[i]->u.tex.first_layer;
217 blit.dst.box.depth = 1;
218 vlVaGetBox(dst, i, &blit.dst.box, dst_region);
219
220 blit.mask = PIPE_MASK_RGBA;
221 blit.filter = PIPE_TEX_MIPFILTER_LINEAR;
222
223 if (drv->pipe->screen->get_param(drv->pipe->screen,
224 PIPE_CAP_PREFER_COMPUTE_FOR_MULTIMEDIA))
225 util_compute_blit(drv->pipe, &blit, &context->blit_cs);
226 else
227 drv->pipe->blit(drv->pipe, &blit);
228 }
229
230 // TODO: figure out why this is necessary for DMA-buf sharing
231 drv->pipe->flush(drv->pipe, NULL, 0);
232
233 return VA_STATUS_SUCCESS;
234 }
235
236 static struct pipe_video_buffer *
vlVaApplyDeint(vlVaDriver * drv,vlVaContext * context,VAProcPipelineParameterBuffer * param,struct pipe_video_buffer * current,unsigned field)237 vlVaApplyDeint(vlVaDriver *drv, vlVaContext *context,
238 VAProcPipelineParameterBuffer *param,
239 struct pipe_video_buffer *current,
240 unsigned field)
241 {
242 vlVaSurface *prevprev, *prev, *next;
243
244 if (param->num_forward_references < 2 ||
245 param->num_backward_references < 1)
246 return current;
247
248 prevprev = handle_table_get(drv->htab, param->forward_references[1]);
249 prev = handle_table_get(drv->htab, param->forward_references[0]);
250 next = handle_table_get(drv->htab, param->backward_references[0]);
251
252 if (!prevprev || !prev || !next)
253 return current;
254
255 if (context->deint && (context->deint->video_width != current->width ||
256 context->deint->video_height != current->height)) {
257 vl_deint_filter_cleanup(context->deint);
258 FREE(context->deint);
259 context->deint = NULL;
260 }
261
262 if (!context->deint) {
263 context->deint = MALLOC(sizeof(struct vl_deint_filter));
264 if (!vl_deint_filter_init(context->deint, drv->pipe, current->width,
265 current->height, false, false)) {
266 FREE(context->deint);
267 context->deint = NULL;
268 return current;
269 }
270 }
271
272 if (!vl_deint_filter_check_buffers(context->deint, prevprev->buffer,
273 prev->buffer, current, next->buffer))
274 return current;
275
276 vl_deint_filter_render(context->deint, prevprev->buffer, prev->buffer,
277 current, next->buffer, field);
278 return context->deint->video_buffer;
279 }
280
281 VAStatus
vlVaHandleVAProcPipelineParameterBufferType(vlVaDriver * drv,vlVaContext * context,vlVaBuffer * buf)282 vlVaHandleVAProcPipelineParameterBufferType(vlVaDriver *drv, vlVaContext *context, vlVaBuffer *buf)
283 {
284 enum vl_compositor_deinterlace deinterlace = VL_COMPOSITOR_WEAVE;
285 VARectangle def_src_region, def_dst_region;
286 const VARectangle *src_region, *dst_region;
287 VAProcPipelineParameterBuffer *param;
288 struct pipe_video_buffer *src;
289 vlVaSurface *src_surface, *dst_surface;
290 unsigned i;
291
292 if (!drv || !context)
293 return VA_STATUS_ERROR_INVALID_CONTEXT;
294
295 if (!buf || !buf->data)
296 return VA_STATUS_ERROR_INVALID_BUFFER;
297
298 if (!context->target)
299 return VA_STATUS_ERROR_INVALID_SURFACE;
300
301 param = buf->data;
302
303 src_surface = handle_table_get(drv->htab, param->surface);
304 dst_surface = handle_table_get(drv->htab, context->target_id);
305
306 if (!src_surface || !src_surface->buffer)
307 return VA_STATUS_ERROR_INVALID_SURFACE;
308
309 src = src_surface->buffer;
310
311 for (i = 0; i < param->num_filters; i++) {
312 vlVaBuffer *buf = handle_table_get(drv->htab, param->filters[i]);
313 VAProcFilterParameterBufferBase *filter;
314
315 if (!buf || buf->type != VAProcFilterParameterBufferType)
316 return VA_STATUS_ERROR_INVALID_BUFFER;
317
318 filter = buf->data;
319 switch (filter->type) {
320 case VAProcFilterDeinterlacing: {
321 VAProcFilterParameterBufferDeinterlacing *deint = buf->data;
322 switch (deint->algorithm) {
323 case VAProcDeinterlacingBob:
324 if (deint->flags & VA_DEINTERLACING_BOTTOM_FIELD)
325 deinterlace = VL_COMPOSITOR_BOB_BOTTOM;
326 else
327 deinterlace = VL_COMPOSITOR_BOB_TOP;
328 break;
329
330 case VAProcDeinterlacingWeave:
331 deinterlace = VL_COMPOSITOR_WEAVE;
332 break;
333
334 case VAProcDeinterlacingMotionAdaptive:
335 src = vlVaApplyDeint(drv, context, param, src,
336 !!(deint->flags & VA_DEINTERLACING_BOTTOM_FIELD));
337 break;
338
339 default:
340 return VA_STATUS_ERROR_UNIMPLEMENTED;
341 }
342
343 break;
344 }
345
346 default:
347 return VA_STATUS_ERROR_UNIMPLEMENTED;
348 }
349 }
350
351 src_region = vlVaRegionDefault(param->surface_region, src_surface, &def_src_region);
352 dst_region = vlVaRegionDefault(param->output_region, dst_surface, &def_dst_region);
353
354 if (context->target->buffer_format != PIPE_FORMAT_NV12 &&
355 context->target->buffer_format != PIPE_FORMAT_P010 &&
356 context->target->buffer_format != PIPE_FORMAT_P016)
357 return vlVaPostProcCompositor(drv, context, src_region, dst_region,
358 src, context->target, deinterlace);
359 else
360 return vlVaPostProcBlit(drv, context, src_region, dst_region,
361 src, context->target, deinterlace);
362 }
363