src/gallium/state_trackers/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 "state_tracker/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    pipe_mutex_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    pipe_mutex_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       pipe_mutex_unlock(drv->mutex);
 124       return VA_STATUS_ERROR_INVALID_BUFFER;
 125    }
 126
 127    if (buf->derived_surface.resource) {
 128       *pbuff = pipe_buffer_map(drv->pipe, buf->derived_surface.resource,
 129                                PIPE_TRANSFER_WRITE,
 130                                &buf->derived_surface.transfer);
 131       pipe_mutex_unlock(drv->mutex);
 132
 133       if (!buf->derived_surface.transfer || !*pbuff)
 134          return VA_STATUS_ERROR_INVALID_BUFFER;
 135
 136       if (buf->type == VAEncCodedBufferType) {
 137          ((VACodedBufferSegment*)buf->data)->buf = *pbuff;
 138          ((VACodedBufferSegment*)buf->data)->size = buf->coded_size;
 139          ((VACodedBufferSegment*)buf->data)->next = NULL;
 140          *pbuff = buf->data;
 141       }
 142    } else {
 143       pipe_mutex_unlock(drv->mutex);
 144       *pbuff = buf->data;
 145    }
 146
 147    return VA_STATUS_SUCCESS;
 148 }
 149
 150 VAStatus
 151 vlVaUnmapBuffer(VADriverContextP ctx, VABufferID buf_id)
 152 {
 153    vlVaDriver *drv;
 154    vlVaBuffer *buf;
 155
 156    if (!ctx)
 157       return VA_STATUS_ERROR_INVALID_CONTEXT;
 158
 159    drv = VL_VA_DRIVER(ctx);
 160    if (!drv)
 161       return VA_STATUS_ERROR_INVALID_CONTEXT;
 162
 163    mtx_lock(&drv->mutex);
 164    buf = handle_table_get(drv->htab, buf_id);
 165    if (!buf || buf->export_refcount > 0) {
 166       pipe_mutex_unlock(drv->mutex);
 167       return VA_STATUS_ERROR_INVALID_BUFFER;
 168    }
 169
 170    if (buf->derived_surface.resource) {
 171       if (!buf->derived_surface.transfer) {
 172          pipe_mutex_unlock(drv->mutex);
 173          return VA_STATUS_ERROR_INVALID_BUFFER;
 174       }
 175
 176       pipe_buffer_unmap(drv->pipe, buf->derived_surface.transfer);
 177       buf->derived_surface.transfer = NULL;
 178    }
 179    pipe_mutex_unlock(drv->mutex);
 180
 181    return VA_STATUS_SUCCESS;
 182 }
 183
 184 VAStatus
 185 vlVaDestroyBuffer(VADriverContextP ctx, VABufferID buf_id)
 186 {
 187    vlVaDriver *drv;
 188    vlVaBuffer *buf;
 189
 190    if (!ctx)
 191       return VA_STATUS_ERROR_INVALID_CONTEXT;
 192
 193    drv = VL_VA_DRIVER(ctx);
 194    mtx_lock(&drv->mutex);
 195    buf = handle_table_get(drv->htab, buf_id);
 196    if (!buf) {
 197       pipe_mutex_unlock(drv->mutex);
 198       return VA_STATUS_ERROR_INVALID_BUFFER;
 199    }
 200
 201    if (buf->derived_surface.resource)
 202       pipe_resource_reference(&buf->derived_surface.resource, NULL);
 203
 204    FREE(buf->data);
 205    FREE(buf);
 206    handle_table_remove(VL_VA_DRIVER(ctx)->htab, buf_id);
 207    pipe_mutex_unlock(drv->mutex);
 208
 209    return VA_STATUS_SUCCESS;
 210 }
 211
 212 VAStatus
 213 vlVaBufferInfo(VADriverContextP ctx, VABufferID buf_id, VABufferType *type,
 214                unsigned int *size, unsigned int *num_elements)
 215 {
 216    vlVaDriver *drv;
 217    vlVaBuffer *buf;
 218
 219    if (!ctx)
 220       return VA_STATUS_ERROR_INVALID_CONTEXT;
 221
 222    drv = VL_VA_DRIVER(ctx);
 223    mtx_lock(&drv->mutex);
 224    buf = handle_table_get(drv->htab, buf_id);
 225    pipe_mutex_unlock(drv->mutex);
 226    if (!buf)
 227       return VA_STATUS_ERROR_INVALID_BUFFER;
 228
 229    *type = buf->type;
 230    *size = buf->size;
 231    *num_elements = buf->num_elements;
 232
 233    return VA_STATUS_SUCCESS;
 234 }
 235
 236 VAStatus
 237 vlVaAcquireBufferHandle(VADriverContextP ctx, VABufferID buf_id,
 238                         VABufferInfo *out_buf_info)
 239 {
 240    vlVaDriver *drv;
 241    uint32_t i;
 242    uint32_t mem_type;
 243    vlVaBuffer *buf ;
 244    struct pipe_screen *screen;
 245
 246    /* List of supported memory types, in preferred order. */
 247    static const uint32_t mem_types[] = {
 248       VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME,
 249       0
 250    };
 251
 252    if (!ctx)
 253       return VA_STATUS_ERROR_INVALID_CONTEXT;
 254
 255    drv = VL_VA_DRIVER(ctx);
 256    screen = VL_VA_PSCREEN(ctx);
 257    mtx_lock(&drv->mutex);
 258    buf = handle_table_get(VL_VA_DRIVER(ctx)->htab, buf_id);
 259    pipe_mutex_unlock(drv->mutex);
 260
 261    if (!buf)
 262       return VA_STATUS_ERROR_INVALID_BUFFER;
 263
 264    /* Only VA surface|image like buffers are supported for now .*/
 265    if (buf->type != VAImageBufferType)
 266       return VA_STATUS_ERROR_UNSUPPORTED_BUFFERTYPE;
 267
 268    if (!out_buf_info)
 269       return VA_STATUS_ERROR_INVALID_PARAMETER;
 270
 271    if (!out_buf_info->mem_type)
 272       mem_type = mem_types[0];
 273    else {
 274       mem_type = 0;
 275       for (i = 0; mem_types[i] != 0; i++) {
 276          if (out_buf_info->mem_type & mem_types[i]) {
 277             mem_type = out_buf_info->mem_type;
 278             break;
 279          }
 280       }
 281       if (!mem_type)
 282          return VA_STATUS_ERROR_UNSUPPORTED_MEMORY_TYPE;
 283    }
 284
 285    if (!buf->derived_surface.resource)
 286       return VA_STATUS_ERROR_INVALID_BUFFER;
 287
 288    if (buf->export_refcount > 0) {
 289       if (buf->export_state.mem_type != mem_type)
 290          return VA_STATUS_ERROR_INVALID_PARAMETER;
 291    } else {
 292       VABufferInfo * const buf_info = &buf->export_state;
 293
 294       switch (mem_type) {
 295       case VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME: {
 296          struct winsys_handle whandle;
 297
 298          mtx_lock(&drv->mutex);
 299          drv->pipe->flush(drv->pipe, NULL, 0);
 300
 301          memset(&whandle, 0, sizeof(whandle));
 302          whandle.type = DRM_API_HANDLE_TYPE_FD;
 303
 304          if (!screen->resource_get_handle(screen, drv->pipe,
 305                                           buf->derived_surface.resource,
 306                                           &whandle, PIPE_HANDLE_USAGE_READ_WRITE)) {
 307             pipe_mutex_unlock(drv->mutex);
 308             return VA_STATUS_ERROR_INVALID_BUFFER;
 309          }
 310
 311          pipe_mutex_unlock(drv->mutex);
 312
 313          buf_info->handle = (intptr_t)whandle.handle;
 314          break;
 315       }
 316       default:
 317          return VA_STATUS_ERROR_UNSUPPORTED_MEMORY_TYPE;
 318       }
 319
 320       buf_info->type = buf->type;
 321       buf_info->mem_type = mem_type;
 322       buf_info->mem_size = buf->num_elements * buf->size;
 323    }
 324
 325    buf->export_refcount++;
 326
 327    *out_buf_info = buf->export_state;
 328
 329    return VA_STATUS_SUCCESS;
 330 }
 331
 332 VAStatus
 333 vlVaReleaseBufferHandle(VADriverContextP ctx, VABufferID buf_id)
 334 {
 335    vlVaDriver *drv;
 336    vlVaBuffer *buf;
 337
 338    if (!ctx)
 339       return VA_STATUS_ERROR_INVALID_CONTEXT;
 340
 341    drv = VL_VA_DRIVER(ctx);
 342    mtx_lock(&drv->mutex);
 343    buf = handle_table_get(drv->htab, buf_id);
 344    pipe_mutex_unlock(drv->mutex);
 345
 346    if (!buf)
 347       return VA_STATUS_ERROR_INVALID_BUFFER;
 348
 349    if (buf->export_refcount == 0)
 350       return VA_STATUS_ERROR_INVALID_BUFFER;
 351
 352    if (--buf->export_refcount == 0) {
 353       VABufferInfo * const buf_info = &buf->export_state;
 354
 355       switch (buf_info->mem_type) {
 356       case VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME:
 357          close((intptr_t)buf_info->handle);
 358          break;
 359       default:
 360          return VA_STATUS_ERROR_INVALID_BUFFER;
 361       }
 362
 363       buf_info->mem_type = 0;
 364    }
 365
 366    return VA_STATUS_SUCCESS;
 367 }