src/gallium/state_trackers/va/surface.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2010 Thomas Balling Sørensen & Orasanu Lucian.
   4  * Copyright 2014 Advanced Micro Devices, Inc.
   5  * All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the
   9  * "Software"), to deal in the Software without restriction, including
  10  * without limitation the rights to use, copy, modify, merge, publish,
  11  * distribute, sub license, and/or sell copies of the Software, and to
  12  * permit persons to whom the Software is furnished to do so, subject to
  13  * the following conditions:
  14  *
  15  * The above copyright notice and this permission notice (including the
  16  * next paragraph) shall be included in all copies or substantial portions
  17  * of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  22  * IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR
  23  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  24  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  25  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26  *
  27  **************************************************************************/
  28
  29 #include "pipe/p_screen.h"
  30 #include "pipe/p_video_codec.h"
  31
  32 #include "state_tracker/drm_driver.h"
  33
  34 #include "util/u_memory.h"
  35 #include "util/u_handle_table.h"
  36 #include "util/u_rect.h"
  37 #include "util/u_sampler.h"
  38 #include "util/u_surface.h"
  39
  40 #include "vl/vl_compositor.h"
  41 #include "vl/vl_video_buffer.h"
  42 #include "vl/vl_winsys.h"
  43
  44 #include "va_private.h"
  45
  46 DEBUG_GET_ONCE_BOOL_OPTION(nointerlace, "VAAPI_DISABLE_INTERLACE", FALSE);
  47
  48 #include <va/va_drmcommon.h>
  49
  50 static const enum pipe_format vpp_surface_formats[] = {
  51    PIPE_FORMAT_B8G8R8A8_UNORM, PIPE_FORMAT_R8G8B8A8_UNORM,
  52    PIPE_FORMAT_B8G8R8X8_UNORM, PIPE_FORMAT_R8G8B8X8_UNORM
  53 };
  54
  55 VAStatus
  56 vlVaCreateSurfaces(VADriverContextP ctx, int width, int height, int format,
  57                    int num_surfaces, VASurfaceID *surfaces)
  58 {
  59    return vlVaCreateSurfaces2(ctx, format, width, height, surfaces, num_surfaces,
  60                               NULL, 0);
  61 }
  62
  63 VAStatus
  64 vlVaDestroySurfaces(VADriverContextP ctx, VASurfaceID *surface_list, int num_surfaces)
  65 {
  66    vlVaDriver *drv;
  67    int i;
  68
  69    if (!ctx)
  70       return VA_STATUS_ERROR_INVALID_CONTEXT;
  71
  72    drv = VL_VA_DRIVER(ctx);
  73    mtx_lock(&drv->mutex);
  74    for (i = 0; i < num_surfaces; ++i) {
  75       vlVaSurface *surf = handle_table_get(drv->htab, surface_list[i]);
  76       if (!surf) {
  77          mtx_unlock(&drv->mutex);
  78          return VA_STATUS_ERROR_INVALID_SURFACE;
  79       }
  80       if (surf->buffer)
  81          surf->buffer->destroy(surf->buffer);
  82       util_dynarray_fini(&surf->subpics);
  83       FREE(surf);
  84       handle_table_remove(drv->htab, surface_list[i]);
  85    }
  86    mtx_unlock(&drv->mutex);
  87
  88    return VA_STATUS_SUCCESS;
  89 }
  90
  91 VAStatus
  92 vlVaSyncSurface(VADriverContextP ctx, VASurfaceID render_target)
  93 {
  94    vlVaDriver *drv;
  95    vlVaContext *context;
  96    vlVaSurface *surf;
  97
  98    if (!ctx)
  99       return VA_STATUS_ERROR_INVALID_CONTEXT;
 100
 101    drv = VL_VA_DRIVER(ctx);
 102    if (!drv)
 103       return VA_STATUS_ERROR_INVALID_CONTEXT;
 104
 105    mtx_lock(&drv->mutex);
 106    surf = handle_table_get(drv->htab, render_target);
 107
 108    if (!surf || !surf->buffer) {
 109       mtx_unlock(&drv->mutex);
 110       return VA_STATUS_ERROR_INVALID_SURFACE;
 111    }
 112
 113    if (!surf->feedback) {
 114       // No outstanding operation: nothing to do.
 115       mtx_unlock(&drv->mutex);
 116       return VA_STATUS_SUCCESS;
 117    }
 118
 119    context = handle_table_get(drv->htab, surf->ctx);
 120    if (!context) {
 121       mtx_unlock(&drv->mutex);
 122       return VA_STATUS_ERROR_INVALID_CONTEXT;
 123    }
 124
 125    if (context->decoder->entrypoint == PIPE_VIDEO_ENTRYPOINT_ENCODE) {
 126       int frame_diff;
 127       if (context->desc.h264enc.frame_num_cnt >= surf->frame_num_cnt)
 128          frame_diff = context->desc.h264enc.frame_num_cnt - surf->frame_num_cnt;
 129       else
 130          frame_diff = 0xFFFFFFFF - surf->frame_num_cnt + 1 + context->desc.h264enc.frame_num_cnt;
 131       if ((frame_diff == 0) &&
 132           (surf->force_flushed == false) &&
 133           (context->desc.h264enc.frame_num_cnt % 2 != 0)) {
 134          context->decoder->flush(context->decoder);
 135          context->first_single_submitted = true;
 136       }
 137       context->decoder->get_feedback(context->decoder, surf->feedback, &(surf->coded_buf->coded_size));
 138       surf->feedback = NULL;
 139    }
 140    mtx_unlock(&drv->mutex);
 141    return VA_STATUS_SUCCESS;
 142 }
 143
 144 VAStatus
 145 vlVaQuerySurfaceStatus(VADriverContextP ctx, VASurfaceID render_target, VASurfaceStatus *status)
 146 {
 147    if (!ctx)
 148       return VA_STATUS_ERROR_INVALID_CONTEXT;
 149
 150    return VA_STATUS_SUCCESS;
 151 }
 152
 153 VAStatus
 154 vlVaQuerySurfaceError(VADriverContextP ctx, VASurfaceID render_target, VAStatus error_status, void **error_info)
 155 {
 156    if (!ctx)
 157       return VA_STATUS_ERROR_INVALID_CONTEXT;
 158
 159    return VA_STATUS_ERROR_UNIMPLEMENTED;
 160 }
 161
 162 static void
 163 upload_sampler(struct pipe_context *pipe, struct pipe_sampler_view *dst,
 164                const struct pipe_box *dst_box, const void *src, unsigned src_stride,
 165                unsigned src_x, unsigned src_y)
 166 {
 167    struct pipe_transfer *transfer;
 168    void *map;
 169
 170    map = pipe->transfer_map(pipe, dst->texture, 0, PIPE_TRANSFER_WRITE,
 171                             dst_box, &transfer);
 172    if (!map)
 173       return;
 174
 175    util_copy_rect(map, dst->texture->format, transfer->stride, 0, 0,
 176                   dst_box->width, dst_box->height,
 177                   src, src_stride, src_x, src_y);
 178
 179    pipe->transfer_unmap(pipe, transfer);
 180 }
 181
 182 static VAStatus
 183 vlVaPutSubpictures(vlVaSurface *surf, vlVaDriver *drv,
 184                    struct pipe_surface *surf_draw, struct u_rect *dirty_area,
 185                    struct u_rect *src_rect, struct u_rect *dst_rect)
 186 {
 187    vlVaSubpicture *sub;
 188    int i;
 189
 190    if (!(surf->subpics.data || surf->subpics.size))
 191       return VA_STATUS_SUCCESS;
 192
 193    for (i = 0; i < surf->subpics.size/sizeof(vlVaSubpicture *); i++) {
 194       struct pipe_blend_state blend;
 195       void *blend_state;
 196       vlVaBuffer *buf;
 197       struct pipe_box box;
 198       struct u_rect *s, *d, sr, dr, c;
 199       int sw, sh, dw, dh;
 200
 201       sub = ((vlVaSubpicture **)surf->subpics.data)[i];
 202       if (!sub)
 203          continue;
 204
 205       buf = handle_table_get(drv->htab, sub->image->buf);
 206       if (!buf)
 207          return VA_STATUS_ERROR_INVALID_IMAGE;
 208
 209       box.x = 0;
 210       box.y = 0;
 211       box.z = 0;
 212       box.width = sub->dst_rect.x1 - sub->dst_rect.x0;
 213       box.height = sub->dst_rect.y1 - sub->dst_rect.y0;
 214       box.depth = 1;
 215
 216       s = &sub->src_rect;
 217       d = &sub->dst_rect;
 218       sw = s->x1 - s->x0;
 219       sh = s->y1 - s->y0;
 220       dw = d->x1 - d->x0;
 221       dh = d->y1 - d->y0;
 222       c.x0 = MAX2(d->x0, s->x0);
 223       c.y0 = MAX2(d->y0, s->y0);
 224       c.x1 = MIN2(d->x0 + dw, src_rect->x1);
 225       c.y1 = MIN2(d->y0 + dh, src_rect->y1);
 226       sr.x0 = s->x0 + (c.x0 - d->x0)*(sw/(float)dw);
 227       sr.y0 = s->y0 + (c.y0 - d->y0)*(sh/(float)dh);
 228       sr.x1 = s->x0 + (c.x1 - d->x0)*(sw/(float)dw);
 229       sr.y1 = s->y0 + (c.y1 - d->y0)*(sh/(float)dh);
 230
 231       s = src_rect;
 232       d = dst_rect;
 233       sw = s->x1 - s->x0;
 234       sh = s->y1 - s->y0;
 235       dw = d->x1 - d->x0;
 236       dh = d->y1 - d->y0;
 237       dr.x0 = d->x0 + c.x0*(dw/(float)sw);
 238       dr.y0 = d->y0 + c.y0*(dh/(float)sh);
 239       dr.x1 = d->x0 + c.x1*(dw/(float)sw);
 240       dr.y1 = d->y0 + c.y1*(dh/(float)sh);
 241
 242       memset(&blend, 0, sizeof(blend));
 243       blend.independent_blend_enable = 0;
 244       blend.rt[0].blend_enable = 1;
 245       blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_SRC_ALPHA;
 246       blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_INV_SRC_ALPHA;
 247       blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ZERO;
 248       blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
 249       blend.rt[0].rgb_func = PIPE_BLEND_ADD;
 250       blend.rt[0].alpha_func = PIPE_BLEND_ADD;
 251       blend.rt[0].colormask = PIPE_MASK_RGBA;
 252       blend.logicop_enable = 0;
 253       blend.logicop_func = PIPE_LOGICOP_CLEAR;
 254       blend.dither = 0;
 255       blend_state = drv->pipe->create_blend_state(drv->pipe, &blend);
 256
 257       vl_compositor_clear_layers(&drv->cstate);
 258       vl_compositor_set_layer_blend(&drv->cstate, 0, blend_state, false);
 259       upload_sampler(drv->pipe, sub->sampler, &box, buf->data,
 260                      sub->image->pitches[0], 0, 0);
 261       vl_compositor_set_rgba_layer(&drv->cstate, &drv->compositor, 0, sub->sampler,
 262                                    &sr, NULL, NULL);
 263       vl_compositor_set_layer_dst_area(&drv->cstate, 0, &dr);
 264       vl_compositor_render(&drv->cstate, &drv->compositor, surf_draw, dirty_area, false);
 265       drv->pipe->delete_blend_state(drv->pipe, blend_state);
 266    }
 267
 268    return VA_STATUS_SUCCESS;
 269 }
 270
 271 VAStatus
 272 vlVaPutSurface(VADriverContextP ctx, VASurfaceID surface_id, void* draw, short srcx, short srcy,
 273                unsigned short srcw, unsigned short srch, short destx, short desty,
 274                unsigned short destw, unsigned short desth, VARectangle *cliprects,
 275                unsigned int number_cliprects,  unsigned int flags)
 276 {
 277    vlVaDriver *drv;
 278    vlVaSurface *surf;
 279    struct pipe_screen *screen;
 280    struct pipe_resource *tex;
 281    struct pipe_surface surf_templ, *surf_draw;
 282    struct vl_screen *vscreen;
 283    struct u_rect src_rect, *dirty_area;
 284    struct u_rect dst_rect = {destx, destx + destw, desty, desty + desth};
 285    VAStatus status;
 286
 287    if (!ctx)
 288       return VA_STATUS_ERROR_INVALID_CONTEXT;
 289
 290    drv = VL_VA_DRIVER(ctx);
 291    mtx_lock(&drv->mutex);
 292    surf = handle_table_get(drv->htab, surface_id);
 293    if (!surf) {
 294       mtx_unlock(&drv->mutex);
 295       return VA_STATUS_ERROR_INVALID_SURFACE;
 296    }
 297
 298    screen = drv->pipe->screen;
 299    vscreen = drv->vscreen;
 300
 301    tex = vscreen->texture_from_drawable(vscreen, draw);
 302    if (!tex) {
 303       mtx_unlock(&drv->mutex);
 304       return VA_STATUS_ERROR_INVALID_DISPLAY;
 305    }
 306
 307    dirty_area = vscreen->get_dirty_area(vscreen);
 308
 309    memset(&surf_templ, 0, sizeof(surf_templ));
 310    surf_templ.format = tex->format;
 311    surf_draw = drv->pipe->create_surface(drv->pipe, tex, &surf_templ);
 312    if (!surf_draw) {
 313       pipe_resource_reference(&tex, NULL);
 314       mtx_unlock(&drv->mutex);
 315       return VA_STATUS_ERROR_INVALID_DISPLAY;
 316    }
 317
 318    src_rect.x0 = srcx;
 319    src_rect.y0 = srcy;
 320    src_rect.x1 = srcw + srcx;
 321    src_rect.y1 = srch + srcy;
 322
 323    vl_compositor_clear_layers(&drv->cstate);
 324    vl_compositor_set_buffer_layer(&drv->cstate, &drv->compositor, 0, surf->buffer, &src_rect, NULL, VL_COMPOSITOR_WEAVE);
 325    vl_compositor_set_layer_dst_area(&drv->cstate, 0, &dst_rect);
 326    vl_compositor_render(&drv->cstate, &drv->compositor, surf_draw, dirty_area, true);
 327
 328    status = vlVaPutSubpictures(surf, drv, surf_draw, dirty_area, &src_rect, &dst_rect);
 329    if (status) {
 330       mtx_unlock(&drv->mutex);
 331       return status;
 332    }
 333
 334    /* flush before calling flush_frontbuffer so that rendering is flushed
 335     * to back buffer so the texture can be copied in flush_frontbuffer
 336     */
 337    drv->pipe->flush(drv->pipe, NULL, 0);
 338
 339    screen->flush_frontbuffer(screen, tex, 0, 0,
 340                              vscreen->get_private(vscreen), NULL);
 341
 342
 343    pipe_resource_reference(&tex, NULL);
 344    pipe_surface_reference(&surf_draw, NULL);
 345    mtx_unlock(&drv->mutex);
 346
 347    return VA_STATUS_SUCCESS;
 348 }
 349
 350 VAStatus
 351 vlVaLockSurface(VADriverContextP ctx, VASurfaceID surface, unsigned int *fourcc,
 352                 unsigned int *luma_stride, unsigned int *chroma_u_stride, unsigned int *chroma_v_stride,
 353                 unsigned int *luma_offset, unsigned int *chroma_u_offset, unsigned int *chroma_v_offset,
 354                 unsigned int *buffer_name, void **buffer)
 355 {
 356    if (!ctx)
 357       return VA_STATUS_ERROR_INVALID_CONTEXT;
 358
 359    return VA_STATUS_ERROR_UNIMPLEMENTED;
 360 }
 361
 362 VAStatus
 363 vlVaUnlockSurface(VADriverContextP ctx, VASurfaceID surface)
 364 {
 365    if (!ctx)
 366       return VA_STATUS_ERROR_INVALID_CONTEXT;
 367
 368    return VA_STATUS_ERROR_UNIMPLEMENTED;
 369 }
 370
 371 VAStatus
 372 vlVaQuerySurfaceAttributes(VADriverContextP ctx, VAConfigID config_id,
 373                            VASurfaceAttrib *attrib_list, unsigned int *num_attribs)
 374 {
 375    vlVaDriver *drv;
 376    vlVaConfig *config;
 377    VASurfaceAttrib *attribs;
 378    struct pipe_screen *pscreen;
 379    int i, j;
 380
 381    STATIC_ASSERT(ARRAY_SIZE(vpp_surface_formats) <= VL_VA_MAX_IMAGE_FORMATS);
 382
 383    if (config_id == VA_INVALID_ID)
 384       return VA_STATUS_ERROR_INVALID_CONFIG;
 385
 386    if (!attrib_list && !num_attribs)
 387       return VA_STATUS_ERROR_INVALID_PARAMETER;
 388
 389    if (!attrib_list) {
 390       *num_attribs = VL_VA_MAX_IMAGE_FORMATS + VASurfaceAttribCount;
 391       return VA_STATUS_SUCCESS;
 392    }
 393
 394    if (!ctx)
 395       return VA_STATUS_ERROR_INVALID_CONTEXT;
 396
 397    drv = VL_VA_DRIVER(ctx);
 398
 399    if (!drv)
 400       return VA_STATUS_ERROR_INVALID_CONTEXT;
 401
 402    mtx_lock(&drv->mutex);
 403    config = handle_table_get(drv->htab, config_id);
 404    mtx_unlock(&drv->mutex);
 405
 406    if (!config)
 407       return VA_STATUS_ERROR_INVALID_CONFIG;
 408
 409    pscreen = VL_VA_PSCREEN(ctx);
 410
 411    if (!pscreen)
 412       return VA_STATUS_ERROR_INVALID_CONTEXT;
 413
 414    attribs = CALLOC(VL_VA_MAX_IMAGE_FORMATS + VASurfaceAttribCount,
 415                     sizeof(VASurfaceAttrib));
 416
 417    if (!attribs)
 418       return VA_STATUS_ERROR_ALLOCATION_FAILED;
 419
 420    i = 0;
 421
 422    /* vlVaCreateConfig returns PIPE_VIDEO_PROFILE_UNKNOWN
 423     * only for VAEntrypointVideoProc. */
 424    if (config->profile == PIPE_VIDEO_PROFILE_UNKNOWN) {
 425       if (config->rt_format & VA_RT_FORMAT_RGB32) {
 426          for (j = 0; j < ARRAY_SIZE(vpp_surface_formats); ++j) {
 427             attribs[i].type = VASurfaceAttribPixelFormat;
 428             attribs[i].value.type = VAGenericValueTypeInteger;
 429             attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
 430             attribs[i].value.value.i = PipeFormatToVaFourcc(vpp_surface_formats[j]);
 431             i++;
 432          }
 433       }
 434    }
 435    if (config->rt_format & VA_RT_FORMAT_YUV420) {
 436       attribs[i].type = VASurfaceAttribPixelFormat;
 437       attribs[i].value.type = VAGenericValueTypeInteger;
 438       attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
 439       attribs[i].value.value.i = VA_FOURCC_NV12;
 440       i++;
 441    }
 442    if (config->rt_format & VA_RT_FORMAT_YUV420_10BPP) {
 443       attribs[i].type = VASurfaceAttribPixelFormat;
 444       attribs[i].value.type = VAGenericValueTypeInteger;
 445       attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
 446       attribs[i].value.value.i = VA_FOURCC_P010;
 447       i++;
 448       attribs[i].type = VASurfaceAttribPixelFormat;
 449       attribs[i].value.type = VAGenericValueTypeInteger;
 450       attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
 451       attribs[i].value.value.i = VA_FOURCC_P016;
 452       i++;
 453    }
 454
 455    attribs[i].type = VASurfaceAttribMemoryType;
 456    attribs[i].value.type = VAGenericValueTypeInteger;
 457    attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
 458    attribs[i].value.value.i = VA_SURFACE_ATTRIB_MEM_TYPE_VA |
 459          VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME;
 460    i++;
 461
 462    attribs[i].type = VASurfaceAttribExternalBufferDescriptor;
 463    attribs[i].value.type = VAGenericValueTypePointer;
 464    attribs[i].flags = VA_SURFACE_ATTRIB_SETTABLE;
 465    attribs[i].value.value.p = NULL; /* ignore */
 466    i++;
 467
 468    attribs[i].type = VASurfaceAttribMaxWidth;
 469    attribs[i].value.type = VAGenericValueTypeInteger;
 470    attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE;
 471    attribs[i].value.value.i = vl_video_buffer_max_size(pscreen);
 472    i++;
 473
 474    attribs[i].type = VASurfaceAttribMaxHeight;
 475    attribs[i].value.type = VAGenericValueTypeInteger;
 476    attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE;
 477    attribs[i].value.value.i = vl_video_buffer_max_size(pscreen);
 478    i++;
 479
 480    if (i > *num_attribs) {
 481       *num_attribs = i;
 482       FREE(attribs);
 483       return VA_STATUS_ERROR_MAX_NUM_EXCEEDED;
 484    }
 485
 486    *num_attribs = i;
 487    memcpy(attrib_list, attribs, i * sizeof(VASurfaceAttrib));
 488    FREE(attribs);
 489
 490    return VA_STATUS_SUCCESS;
 491 }
 492
 493 static VAStatus
 494 suface_from_external_memory(VADriverContextP ctx, vlVaSurface *surface,
 495                             VASurfaceAttribExternalBuffers *memory_attibute,
 496                             unsigned index, struct pipe_video_buffer *templat)
 497 {
 498    vlVaDriver *drv;
 499    struct pipe_screen *pscreen;
 500    struct pipe_resource *resource;
 501    struct pipe_resource res_templ;
 502    struct winsys_handle whandle;
 503    struct pipe_resource *resources[VL_NUM_COMPONENTS];
 504
 505    pscreen = VL_VA_PSCREEN(ctx);
 506    drv = VL_VA_DRIVER(ctx);
 507
 508    if (!memory_attibute || !memory_attibute->buffers ||
 509        index > memory_attibute->num_buffers)
 510       return VA_STATUS_ERROR_INVALID_PARAMETER;
 511
 512    if (surface->templat.width != memory_attibute->width ||
 513        surface->templat.height != memory_attibute->height ||
 514        memory_attibute->num_planes < 1)
 515       return VA_STATUS_ERROR_INVALID_PARAMETER;
 516
 517    switch (memory_attibute->pixel_format) {
 518    case VA_FOURCC_RGBA:
 519    case VA_FOURCC_RGBX:
 520    case VA_FOURCC_BGRA:
 521    case VA_FOURCC_BGRX:
 522       if (memory_attibute->num_planes != 1)
 523          return VA_STATUS_ERROR_INVALID_PARAMETER;
 524       break;
 525    default:
 526       return VA_STATUS_ERROR_INVALID_PARAMETER;
 527    }
 528
 529    memset(&res_templ, 0, sizeof(res_templ));
 530    res_templ.target = PIPE_TEXTURE_2D;
 531    res_templ.last_level = 0;
 532    res_templ.depth0 = 1;
 533    res_templ.array_size = 1;
 534    res_templ.width0 = memory_attibute->width;
 535    res_templ.height0 = memory_attibute->height;
 536    res_templ.format = surface->templat.buffer_format;
 537    res_templ.bind = PIPE_BIND_SAMPLER_VIEW;
 538    res_templ.usage = PIPE_USAGE_DEFAULT;
 539
 540    memset(&whandle, 0, sizeof(struct winsys_handle));
 541    whandle.type = DRM_API_HANDLE_TYPE_FD;
 542    whandle.handle = memory_attibute->buffers[index];
 543    whandle.stride = memory_attibute->pitches[index];
 544
 545    resource = pscreen->resource_from_handle(pscreen, &res_templ, &whandle,
 546                                             PIPE_HANDLE_USAGE_READ_WRITE);
 547
 548    if (!resource)
 549       return VA_STATUS_ERROR_ALLOCATION_FAILED;
 550
 551    memset(resources, 0, sizeof resources);
 552    resources[0] = resource;
 553
 554    surface->buffer = vl_video_buffer_create_ex2(drv->pipe, templat, resources);
 555    if (!surface->buffer)
 556       return VA_STATUS_ERROR_ALLOCATION_FAILED;
 557
 558    return VA_STATUS_SUCCESS;
 559 }
 560
 561 VAStatus
 562 vlVaHandleSurfaceAllocate(VADriverContextP ctx, vlVaSurface *surface,
 563                           struct pipe_video_buffer *templat)
 564 {
 565    vlVaDriver *drv;
 566    struct pipe_surface **surfaces;
 567    unsigned i;
 568
 569    drv = VL_VA_DRIVER(ctx);
 570
 571    surface->buffer = drv->pipe->create_video_buffer(drv->pipe, templat);
 572    if (!surface->buffer)
 573       return VA_STATUS_ERROR_ALLOCATION_FAILED;
 574
 575    surfaces = surface->buffer->get_surfaces(surface->buffer);
 576    for (i = 0; i < VL_MAX_SURFACES; ++i) {
 577       union pipe_color_union c = {};
 578
 579       if (!surfaces[i])
 580          continue;
 581
 582       if (i > !!surface->buffer->interlaced)
 583          c.f[0] = c.f[1] = c.f[2] = c.f[3] = 0.5f;
 584
 585       drv->pipe->clear_render_target(drv->pipe, surfaces[i], &c, 0, 0,
 586                                      surfaces[i]->width, surfaces[i]->height,
 587                                      false);
 588    }
 589    drv->pipe->flush(drv->pipe, NULL, 0);
 590
 591    return VA_STATUS_SUCCESS;
 592 }
 593
 594 VAStatus
 595 vlVaCreateSurfaces2(VADriverContextP ctx, unsigned int format,
 596                     unsigned int width, unsigned int height,
 597                     VASurfaceID *surfaces, unsigned int num_surfaces,
 598                     VASurfaceAttrib *attrib_list, unsigned int num_attribs)
 599 {
 600    vlVaDriver *drv;
 601    VASurfaceAttribExternalBuffers *memory_attibute;
 602    struct pipe_video_buffer templat;
 603    struct pipe_screen *pscreen;
 604    int i;
 605    int memory_type;
 606    int expected_fourcc;
 607    VAStatus vaStatus;
 608    vlVaSurface *surf;
 609
 610    if (!ctx)
 611       return VA_STATUS_ERROR_INVALID_CONTEXT;
 612
 613    if (!(width && height))
 614       return VA_STATUS_ERROR_INVALID_IMAGE_FORMAT;
 615
 616    drv = VL_VA_DRIVER(ctx);
 617
 618    if (!drv)
 619       return VA_STATUS_ERROR_INVALID_CONTEXT;
 620
 621    pscreen = VL_VA_PSCREEN(ctx);
 622
 623    if (!pscreen)
 624       return VA_STATUS_ERROR_INVALID_CONTEXT;
 625
 626    /* Default. */
 627    memory_attibute = NULL;
 628    memory_type = VA_SURFACE_ATTRIB_MEM_TYPE_VA;
 629    expected_fourcc = 0;
 630
 631    for (i = 0; i < num_attribs && attrib_list; i++) {
 632       if ((attrib_list[i].type == VASurfaceAttribPixelFormat) &&
 633           (attrib_list[i].flags & VA_SURFACE_ATTRIB_SETTABLE)) {
 634          if (attrib_list[i].value.type != VAGenericValueTypeInteger)
 635             return VA_STATUS_ERROR_INVALID_PARAMETER;
 636          expected_fourcc = attrib_list[i].value.value.i;
 637       }
 638
 639       if ((attrib_list[i].type == VASurfaceAttribMemoryType) &&
 640           (attrib_list[i].flags & VA_SURFACE_ATTRIB_SETTABLE)) {
 641
 642          if (attrib_list[i].value.type != VAGenericValueTypeInteger)
 643             return VA_STATUS_ERROR_INVALID_PARAMETER;
 644
 645          switch (attrib_list[i].value.value.i) {
 646          case VA_SURFACE_ATTRIB_MEM_TYPE_VA:
 647          case VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME:
 648             memory_type = attrib_list[i].value.value.i;
 649             break;
 650          default:
 651             return VA_STATUS_ERROR_UNSUPPORTED_MEMORY_TYPE;
 652          }
 653       }
 654
 655       if ((attrib_list[i].type == VASurfaceAttribExternalBufferDescriptor) &&
 656           (attrib_list[i].flags == VA_SURFACE_ATTRIB_SETTABLE)) {
 657          if (attrib_list[i].value.type != VAGenericValueTypePointer)
 658             return VA_STATUS_ERROR_INVALID_PARAMETER;
 659          memory_attibute = (VASurfaceAttribExternalBuffers *)attrib_list[i].value.value.p;
 660       }
 661    }
 662
 663    if (VA_RT_FORMAT_YUV420 != format &&
 664        VA_RT_FORMAT_YUV422 != format &&
 665        VA_RT_FORMAT_YUV444 != format &&
 666        VA_RT_FORMAT_YUV420_10BPP != format &&
 667        VA_RT_FORMAT_RGB32  != format) {
 668       return VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT;
 669    }
 670
 671    switch (memory_type) {
 672    case VA_SURFACE_ATTRIB_MEM_TYPE_VA:
 673       break;
 674    case VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME:
 675       if (!memory_attibute)
 676          return VA_STATUS_ERROR_INVALID_PARAMETER;
 677
 678       expected_fourcc = memory_attibute->pixel_format;
 679       break;
 680    default:
 681       assert(0);
 682    }
 683
 684    memset(&templat, 0, sizeof(templat));
 685
 686    templat.buffer_format = pscreen->get_video_param(
 687       pscreen,
 688       PIPE_VIDEO_PROFILE_UNKNOWN,
 689       PIPE_VIDEO_ENTRYPOINT_BITSTREAM,
 690       PIPE_VIDEO_CAP_PREFERED_FORMAT
 691    );
 692    templat.interlaced = pscreen->get_video_param(
 693       pscreen,
 694       PIPE_VIDEO_PROFILE_UNKNOWN,
 695       PIPE_VIDEO_ENTRYPOINT_BITSTREAM,
 696       PIPE_VIDEO_CAP_PREFERS_INTERLACED
 697    );
 698
 699    if (expected_fourcc) {
 700       enum pipe_format expected_format = VaFourccToPipeFormat(expected_fourcc);
 701
 702       if (expected_format != templat.buffer_format || memory_attibute)
 703         templat.interlaced = 0;
 704
 705       templat.buffer_format = expected_format;
 706    }
 707
 708    templat.chroma_format = ChromaToPipe(format);
 709
 710    templat.width = width;
 711    templat.height = height;
 712    if (debug_get_option_nointerlace())
 713       templat.interlaced = false;
 714
 715    memset(surfaces, VA_INVALID_ID, num_surfaces * sizeof(VASurfaceID));
 716
 717    mtx_lock(&drv->mutex);
 718    for (i = 0; i < num_surfaces; i++) {
 719       surf = CALLOC(1, sizeof(vlVaSurface));
 720       if (!surf) {
 721          vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
 722          goto no_res;
 723       }
 724
 725       surf->templat = templat;
 726
 727       switch (memory_type) {
 728       case VA_SURFACE_ATTRIB_MEM_TYPE_VA:
 729          /* The application will clear the TILING flag when the surface is
 730           * intended to be exported as dmabuf. Adding shared flag because not
 731           * null memory_attibute means VASurfaceAttribExternalBuffers is used.
 732           */
 733          if (memory_attibute &&
 734              !(memory_attibute->flags & VA_SURFACE_EXTBUF_DESC_ENABLE_TILING))
 735             templat.bind = PIPE_BIND_LINEAR | PIPE_BIND_SHARED;
 736
 737          vaStatus = vlVaHandleSurfaceAllocate(ctx, surf, &templat);
 738          if (vaStatus != VA_STATUS_SUCCESS)
 739             goto free_surf;
 740          break;
 741
 742       case VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME:
 743          vaStatus = suface_from_external_memory(ctx, surf, memory_attibute, i, &templat);
 744          if (vaStatus != VA_STATUS_SUCCESS)
 745             goto free_surf;
 746          break;
 747
 748       default:
 749          assert(0);
 750       }
 751
 752       util_dynarray_init(&surf->subpics, NULL);
 753       surfaces[i] = handle_table_add(drv->htab, surf);
 754       if (!surfaces[i]) {
 755          vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
 756          goto destroy_surf;
 757       }
 758    }
 759    mtx_unlock(&drv->mutex);
 760
 761    return VA_STATUS_SUCCESS;
 762
 763 destroy_surf:
 764    surf->buffer->destroy(surf->buffer);
 765
 766 free_surf:
 767    FREE(surf);
 768
 769 no_res:
 770    mtx_unlock(&drv->mutex);
 771    if (i)
 772       vlVaDestroySurfaces(ctx, surfaces, i);
 773
 774    return vaStatus;
 775 }
 776
 777 VAStatus
 778 vlVaQueryVideoProcFilters(VADriverContextP ctx, VAContextID context,
 779                           VAProcFilterType *filters, unsigned int *num_filters)
 780 {
 781    unsigned int num = 0;
 782
 783    if (!ctx)
 784       return VA_STATUS_ERROR_INVALID_CONTEXT;
 785
 786    if (!num_filters || !filters)
 787       return VA_STATUS_ERROR_INVALID_PARAMETER;
 788
 789    filters[num++] = VAProcFilterDeinterlacing;
 790
 791    *num_filters = num;
 792
 793    return VA_STATUS_SUCCESS;
 794 }
 795
 796 VAStatus
 797 vlVaQueryVideoProcFilterCaps(VADriverContextP ctx, VAContextID context,
 798                              VAProcFilterType type, void *filter_caps,
 799                              unsigned int *num_filter_caps)
 800 {
 801    unsigned int i;
 802
 803    if (!ctx)
 804       return VA_STATUS_ERROR_INVALID_CONTEXT;
 805
 806    if (!filter_caps || !num_filter_caps)
 807       return VA_STATUS_ERROR_INVALID_PARAMETER;
 808
 809    i = 0;
 810
 811    switch (type) {
 812    case VAProcFilterNone:
 813       break;
 814    case VAProcFilterDeinterlacing: {
 815       VAProcFilterCapDeinterlacing *deint = filter_caps;
 816
 817       if (*num_filter_caps < 3) {
 818          *num_filter_caps = 3;
 819          return VA_STATUS_ERROR_MAX_NUM_EXCEEDED;
 820       }
 821
 822       deint[i++].type = VAProcDeinterlacingBob;
 823       deint[i++].type = VAProcDeinterlacingWeave;
 824       deint[i++].type = VAProcDeinterlacingMotionAdaptive;
 825       break;
 826    }
 827
 828    case VAProcFilterNoiseReduction:
 829    case VAProcFilterSharpening:
 830    case VAProcFilterColorBalance:
 831    case VAProcFilterSkinToneEnhancement:
 832       return VA_STATUS_ERROR_UNIMPLEMENTED;
 833    default:
 834       assert(0);
 835    }
 836
 837    *num_filter_caps = i;
 838
 839    return VA_STATUS_SUCCESS;
 840 }
 841
 842 static VAProcColorStandardType vpp_input_color_standards[] = {
 843    VAProcColorStandardBT601
 844 };
 845
 846 static VAProcColorStandardType vpp_output_color_standards[] = {
 847    VAProcColorStandardBT601
 848 };
 849
 850 VAStatus
 851 vlVaQueryVideoProcPipelineCaps(VADriverContextP ctx, VAContextID context,
 852                                VABufferID *filters, unsigned int num_filters,
 853                                VAProcPipelineCaps *pipeline_cap)
 854 {
 855    unsigned int i = 0;
 856
 857    if (!ctx)
 858       return VA_STATUS_ERROR_INVALID_CONTEXT;
 859
 860    if (!pipeline_cap)
 861       return VA_STATUS_ERROR_INVALID_PARAMETER;
 862
 863    if (num_filters && !filters)
 864       return VA_STATUS_ERROR_INVALID_PARAMETER;
 865
 866    pipeline_cap->pipeline_flags = 0;
 867    pipeline_cap->filter_flags = 0;
 868    pipeline_cap->num_forward_references = 0;
 869    pipeline_cap->num_backward_references = 0;
 870    pipeline_cap->num_input_color_standards = ARRAY_SIZE(vpp_input_color_standards);
 871    pipeline_cap->input_color_standards = vpp_input_color_standards;
 872    pipeline_cap->num_output_color_standards = ARRAY_SIZE(vpp_output_color_standards);
 873    pipeline_cap->output_color_standards = vpp_output_color_standards;
 874
 875    for (i = 0; i < num_filters; i++) {
 876       vlVaBuffer *buf = handle_table_get(VL_VA_DRIVER(ctx)->htab, filters[i]);
 877       VAProcFilterParameterBufferBase *filter;
 878
 879       if (!buf || buf->type != VAProcFilterParameterBufferType)
 880          return VA_STATUS_ERROR_INVALID_BUFFER;
 881
 882       filter = buf->data;
 883       switch (filter->type) {
 884       case VAProcFilterDeinterlacing: {
 885          VAProcFilterParameterBufferDeinterlacing *deint = buf->data;
 886          if (deint->algorithm == VAProcDeinterlacingMotionAdaptive) {
 887             pipeline_cap->num_forward_references = 2;
 888             pipeline_cap->num_backward_references = 1;
 889          }
 890          break;
 891       }
 892       default:
 893          return VA_STATUS_ERROR_UNIMPLEMENTED;
 894       }
 895    }
 896
 897    return VA_STATUS_SUCCESS;
 898 }