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
38static const VARectangle *
39vlVaRegionDefault(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
53static VAStatus
54vlVaPostProcCompositor(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
89static 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
113static 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, NULL, 0) != 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, !drv->compositor.deinterlace);
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
236static struct pipe_video_buffer *
237vlVaApplyDeint(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
281VAStatus
282vlVaHandleVAProcPipelineParameterBufferType(vlVaDriver *drv, vlVaContext *context, vlVaBuffer *buf)
283{
284   enum vl_compositor_deinterlace deinterlace = VL_COMPOSITOR_NONE;
285   VARectangle def_src_region, def_dst_region;
286   const VARectangle *src_region, *dst_region;
287   VAProcPipelineParameterBuffer *param;
288   struct pipe_video_buffer *src, *dst;
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   dst = dst_surface->buffer;
311
312   /* convert the destination buffer to progressive if we're deinterlacing
313      otherwise we might end up deinterlacing twice */
314   if (param->num_filters && dst->interlaced) {
315      vlVaSurface *surf;
316      surf = dst_surface;
317      surf->templat.interlaced = false;
318      dst->destroy(dst);
319
320      if (vlVaHandleSurfaceAllocate(drv, surf, &surf->templat, NULL, 0) != VA_STATUS_SUCCESS)
321         return VA_STATUS_ERROR_ALLOCATION_FAILED;
322
323      dst = context->target = surf->buffer;
324   }
325
326   for (i = 0; i < param->num_filters; i++) {
327      vlVaBuffer *buf = handle_table_get(drv->htab, param->filters[i]);
328      VAProcFilterParameterBufferBase *filter;
329
330      if (!buf || buf->type != VAProcFilterParameterBufferType)
331         return VA_STATUS_ERROR_INVALID_BUFFER;
332
333      filter = buf->data;
334      switch (filter->type) {
335      case VAProcFilterDeinterlacing: {
336         VAProcFilterParameterBufferDeinterlacing *deint = buf->data;
337         switch (deint->algorithm) {
338         case VAProcDeinterlacingBob:
339            if (deint->flags & VA_DEINTERLACING_BOTTOM_FIELD)
340               deinterlace = VL_COMPOSITOR_BOB_BOTTOM;
341            else
342               deinterlace = VL_COMPOSITOR_BOB_TOP;
343            break;
344
345         case VAProcDeinterlacingWeave:
346            deinterlace = VL_COMPOSITOR_WEAVE;
347            break;
348
349         case VAProcDeinterlacingMotionAdaptive:
350            src = vlVaApplyDeint(drv, context, param, src,
351				 !!(deint->flags & VA_DEINTERLACING_BOTTOM_FIELD));
352             deinterlace = VL_COMPOSITOR_MOTION_ADAPTIVE;
353            break;
354
355         default:
356            return VA_STATUS_ERROR_UNIMPLEMENTED;
357         }
358         drv->compositor.deinterlace = deinterlace;
359         break;
360      }
361
362      default:
363         return VA_STATUS_ERROR_UNIMPLEMENTED;
364      }
365   }
366
367   src_region = vlVaRegionDefault(param->surface_region, src_surface, &def_src_region);
368   dst_region = vlVaRegionDefault(param->output_region, dst_surface, &def_dst_region);
369
370   if (context->target->buffer_format != PIPE_FORMAT_NV12 &&
371       context->target->buffer_format != PIPE_FORMAT_P010 &&
372       context->target->buffer_format != PIPE_FORMAT_P016)
373      return vlVaPostProcCompositor(drv, context, src_region, dst_region,
374                                    src, context->target, deinterlace);
375   else
376      return vlVaPostProcBlit(drv, context, src_region, dst_region,
377                              src, context->target, deinterlace);
378}
379