src/gallium/frontends/va/buffer.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 "frontend/drm_driver.h"
  31 #include "util/u_memory.h"
  32 #include "util/u_handle_table.h"
  33 #include "util/u_transfer.h"
  34 #include "vl/vl_winsys.h"
  35
  36 #include "va_private.h"
  37
  38 VAStatus
  39 vlVaCreateBuffer(VADriverContextP ctx, VAContextID context, VABufferType type,
  40                  unsigned int size, unsigned int num_elements, void *data,
  41                  VABufferID *buf_id)
  42 {
  43    vlVaDriver *drv;
  44    vlVaBuffer *buf;
  45
  46    if (!ctx)
  47       return VA_STATUS_ERROR_INVALID_CONTEXT;
  48
  49    buf = CALLOC(1, sizeof(vlVaBuffer));
  50    if (!buf)
  51       return VA_STATUS_ERROR_ALLOCATION_FAILED;
  52
  53    buf->type = type;
  54    buf->size = size;
  55    buf->num_elements = num_elements;
  56    buf->data = MALLOC(size * num_elements);
  57
  58    if (!buf->data) {
  59       FREE(buf);
  60       return VA_STATUS_ERROR_ALLOCATION_FAILED;
  61    }
  62
  63    if (data)
  64       memcpy(buf->data, data, size * num_elements);
  65
  66    drv = VL_VA_DRIVER(ctx);
  67    mtx_lock(&drv->mutex);
  68    *buf_id = handle_table_add(drv->htab, buf);
  69    mtx_unlock(&drv->mutex);
  70
  71    return VA_STATUS_SUCCESS;
  72 }
  73
  74 VAStatus
  75 vlVaBufferSetNumElements(VADriverContextP ctx, VABufferID buf_id,
  76                          unsigned int num_elements)
  77 {
  78    vlVaDriver *drv;
  79    vlVaBuffer *buf;
  80
  81    if (!ctx)
  82       return VA_STATUS_ERROR_INVALID_CONTEXT;
  83
  84    drv = VL_VA_DRIVER(ctx);
  85    mtx_lock(&drv->mutex);
  86    buf = handle_table_get(drv->htab, buf_id);
  87    mtx_unlock(&drv->mutex);
  88    if (!buf)
  89       return VA_STATUS_ERROR_INVALID_BUFFER;
  90
  91    if (buf->derived_surface.resource)
  92       return VA_STATUS_ERROR_INVALID_BUFFER;
  93
  94    buf->data = REALLOC(buf->data, buf->size * buf->num_elements,
  95                        buf->size * num_elements);
  96    buf->num_elements = num_elements;
  97
  98    if (!buf->data)
  99       return VA_STATUS_ERROR_ALLOCATION_FAILED;
 100
 101    return VA_STATUS_SUCCESS;
 102 }
 103
 104 VAStatus
 105 vlVaMapBuffer(VADriverContextP ctx, VABufferID buf_id, void **pbuff)
 106 {
 107    vlVaDriver *drv;
 108    vlVaBuffer *buf;
 109
 110    if (!ctx)
 111       return VA_STATUS_ERROR_INVALID_CONTEXT;
 112
 113    drv = VL_VA_DRIVER(ctx);
 114    if (!drv)
 115       return VA_STATUS_ERROR_INVALID_CONTEXT;
 116
 117    if (!pbuff)
 118       return VA_STATUS_ERROR_INVALID_PARAMETER;
 119
 120    mtx_lock(&drv->mutex);
 121    buf = handle_table_get(drv->htab, buf_id);
 122    if (!buf || buf->export_refcount > 0) {
 123       mtx_unlock(&drv->mutex);
 124       return VA_STATUS_ERROR_INVALID_BUFFER;
 125    }
 126
 127    if (buf->derived_surface.resource) {
 128       struct pipe_resource *resource;
 129       struct pipe_box box = {};
 130
 131       resource = buf->derived_surface.resource;
 132       box.width = resource->width0;
 133       box.height = resource->height0;
 134       box.depth = resource->depth0;
 135       *pbuff = drv->pipe->transfer_map(drv->pipe, resource, 0, PIPE_TRANSFER_WRITE,
 136                                        &box, &buf->derived_surface.transfer);
 137       mtx_unlock(&drv->mutex);
 138
 139       if (!buf->derived_surface.transfer || !*pbuff)
 140          return VA_STATUS_ERROR_INVALID_BUFFER;
 141
 142       if (buf->type == VAEncCodedBufferType) {
 143          ((VACodedBufferSegment*)buf->data)->buf = *pbuff;
 144          ((VACodedBufferSegment*)buf->data)->size = buf->coded_size;
 145          ((VACodedBufferSegment*)buf->data)->next = NULL;
 146          *pbuff = buf->data;
 147       }
 148    } else {
 149       mtx_unlock(&drv->mutex);
 150       *pbuff = buf->data;
 151    }
 152
 153    return VA_STATUS_SUCCESS;
 154 }
 155
 156 VAStatus
 157 vlVaUnmapBuffer(VADriverContextP ctx, VABufferID buf_id)
 158 {
 159    vlVaDriver *drv;
 160    vlVaBuffer *buf;
 161
 162    if (!ctx)
 163       return VA_STATUS_ERROR_INVALID_CONTEXT;
 164
 165    drv = VL_VA_DRIVER(ctx);
 166    if (!drv)
 167       return VA_STATUS_ERROR_INVALID_CONTEXT;
 168
 169    mtx_lock(&drv->mutex);
 170    buf = handle_table_get(drv->htab, buf_id);
 171    if (!buf || buf->export_refcount > 0) {
 172       mtx_unlock(&drv->mutex);
 173       return VA_STATUS_ERROR_INVALID_BUFFER;
 174    }
 175
 176    if (buf->derived_surface.resource) {
 177       if (!buf->derived_surface.transfer) {
 178          mtx_unlock(&drv->mutex);
 179          return VA_STATUS_ERROR_INVALID_BUFFER;
 180       }
 181
 182       pipe_buffer_unmap(drv->pipe, buf->derived_surface.transfer);
 183       buf->derived_surface.transfer = NULL;
 184    }
 185    mtx_unlock(&drv->mutex);
 186
 187    return VA_STATUS_SUCCESS;
 188 }
 189
 190 VAStatus
 191 vlVaDestroyBuffer(VADriverContextP ctx, VABufferID buf_id)
 192 {
 193    vlVaDriver *drv;
 194    vlVaBuffer *buf;
 195
 196    if (!ctx)
 197       return VA_STATUS_ERROR_INVALID_CONTEXT;
 198
 199    drv = VL_VA_DRIVER(ctx);
 200    mtx_lock(&drv->mutex);
 201    buf = handle_table_get(drv->htab, buf_id);
 202    if (!buf) {
 203       mtx_unlock(&drv->mutex);
 204       return VA_STATUS_ERROR_INVALID_BUFFER;
 205    }
 206
 207    if (buf->derived_surface.resource)
 208       pipe_resource_reference(&buf->derived_surface.resource, NULL);
 209
 210    FREE(buf->data);
 211    FREE(buf);
 212    handle_table_remove(VL_VA_DRIVER(ctx)->htab, buf_id);
 213    mtx_unlock(&drv->mutex);
 214
 215    return VA_STATUS_SUCCESS;
 216 }
 217
 218 VAStatus
 219 vlVaBufferInfo(VADriverContextP ctx, VABufferID buf_id, VABufferType *type,
 220                unsigned int *size, unsigned int *num_elements)
 221 {
 222    vlVaDriver *drv;
 223    vlVaBuffer *buf;
 224
 225    if (!ctx)
 226       return VA_STATUS_ERROR_INVALID_CONTEXT;
 227
 228    drv = VL_VA_DRIVER(ctx);
 229    mtx_lock(&drv->mutex);
 230    buf = handle_table_get(drv->htab, buf_id);
 231    mtx_unlock(&drv->mutex);
 232    if (!buf)
 233       return VA_STATUS_ERROR_INVALID_BUFFER;
 234
 235    *type = buf->type;
 236    *size = buf->size;
 237    *num_elements = buf->num_elements;
 238
 239    return VA_STATUS_SUCCESS;
 240 }
 241
 242 VAStatus
 243 vlVaAcquireBufferHandle(VADriverContextP ctx, VABufferID buf_id,
 244                         VABufferInfo *out_buf_info)
 245 {
 246    vlVaDriver *drv;
 247    uint32_t i;
 248    uint32_t mem_type;
 249    vlVaBuffer *buf ;
 250    struct pipe_screen *screen;
 251
 252    /* List of supported memory types, in preferred order. */
 253    static const uint32_t mem_types[] = {
 254       VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME,
 255       0
 256    };
 257
 258    if (!ctx)
 259       return VA_STATUS_ERROR_INVALID_CONTEXT;
 260
 261    drv = VL_VA_DRIVER(ctx);
 262    screen = VL_VA_PSCREEN(ctx);
 263    mtx_lock(&drv->mutex);
 264    buf = handle_table_get(VL_VA_DRIVER(ctx)->htab, buf_id);
 265    mtx_unlock(&drv->mutex);
 266
 267    if (!buf)
 268       return VA_STATUS_ERROR_INVALID_BUFFER;
 269
 270    /* Only VA surface|image like buffers are supported for now .*/
 271    if (buf->type != VAImageBufferType)
 272       return VA_STATUS_ERROR_UNSUPPORTED_BUFFERTYPE;
 273
 274    if (!out_buf_info)
 275       return VA_STATUS_ERROR_INVALID_PARAMETER;
 276
 277    if (!out_buf_info->mem_type)
 278       mem_type = mem_types[0];
 279    else {
 280       mem_type = 0;
 281       for (i = 0; mem_types[i] != 0; i++) {
 282          if (out_buf_info->mem_type & mem_types[i]) {
 283             mem_type = out_buf_info->mem_type;
 284             break;
 285          }
 286       }
 287       if (!mem_type)
 288          return VA_STATUS_ERROR_UNSUPPORTED_MEMORY_TYPE;
 289    }
 290
 291    if (!buf->derived_surface.resource)
 292       return VA_STATUS_ERROR_INVALID_BUFFER;
 293
 294    if (buf->export_refcount > 0) {
 295       if (buf->export_state.mem_type != mem_type)
 296          return VA_STATUS_ERROR_INVALID_PARAMETER;
 297    } else {
 298       VABufferInfo * const buf_info = &buf->export_state;
 299
 300       switch (mem_type) {
 301       case VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME: {
 302          struct winsys_handle whandle;
 303
 304          mtx_lock(&drv->mutex);
 305          drv->pipe->flush(drv->pipe, NULL, 0);
 306
 307          memset(&whandle, 0, sizeof(whandle));
 308          whandle.type = WINSYS_HANDLE_TYPE_FD;
 309
 310          if (!screen->resource_get_handle(screen, drv->pipe,
 311                                           buf->derived_surface.resource,
 312                                           &whandle, PIPE_HANDLE_USAGE_FRAMEBUFFER_WRITE)) {
 313             mtx_unlock(&drv->mutex);
 314             return VA_STATUS_ERROR_INVALID_BUFFER;
 315          }
 316
 317          mtx_unlock(&drv->mutex);
 318
 319          buf_info->handle = (intptr_t)whandle.handle;
 320          break;
 321       }
 322       default:
 323          return VA_STATUS_ERROR_UNSUPPORTED_MEMORY_TYPE;
 324       }
 325
 326       buf_info->type = buf->type;
 327       buf_info->mem_type = mem_type;
 328       buf_info->mem_size = buf->num_elements * buf->size;
 329    }
 330
 331    buf->export_refcount++;
 332
 333    *out_buf_info = buf->export_state;
 334
 335    return VA_STATUS_SUCCESS;
 336 }
 337
 338 VAStatus
 339 vlVaReleaseBufferHandle(VADriverContextP ctx, VABufferID buf_id)
 340 {
 341    vlVaDriver *drv;
 342    vlVaBuffer *buf;
 343
 344    if (!ctx)
 345       return VA_STATUS_ERROR_INVALID_CONTEXT;
 346
 347    drv = VL_VA_DRIVER(ctx);
 348    mtx_lock(&drv->mutex);
 349    buf = handle_table_get(drv->htab, buf_id);
 350    mtx_unlock(&drv->mutex);
 351
 352    if (!buf)
 353       return VA_STATUS_ERROR_INVALID_BUFFER;
 354
 355    if (buf->export_refcount == 0)
 356       return VA_STATUS_ERROR_INVALID_BUFFER;
 357
 358    if (--buf->export_refcount == 0) {
 359       VABufferInfo * const buf_info = &buf->export_state;
 360
 361       switch (buf_info->mem_type) {
 362       case VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME:
 363          close((intptr_t)buf_info->handle);
 364          break;
 365       default:
 366          return VA_STATUS_ERROR_INVALID_BUFFER;
 367       }
 368
 369       buf_info->mem_type = 0;
 370    }
 371
 372    return VA_STATUS_SUCCESS;
 373 }