src/gallium/state_trackers/vdpau/surface.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2010 Thomas Balling Sørensen.
   4  * Copyright 2011 Christian König.
   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 VMWARE AND/OR ITS SUPPLIERS 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 <assert.h>
  30
  31 #include "pipe/p_state.h"
  32
  33 #include "util/u_memory.h"
  34 #include "util/u_debug.h"
  35 #include "util/u_rect.h"
  36 #include "util/u_surface.h"
  37 #include "util/u_video.h"
  38 #include "vl/vl_defines.h"
  39
  40 #include "state_tracker/drm_driver.h"
  41
  42 #include "vdpau_private.h"
  43
  44 enum getbits_conversion {
  45    CONVERSION_NONE,
  46    CONVERSION_NV12_TO_YV12,
  47    CONVERSION_YV12_TO_NV12,
  48    CONVERSION_SWAP_YUYV_UYVY,
  49 };
  50
  51 /**
  52  * Create a VdpVideoSurface.
  53  */
  54 VdpStatus
  55 vlVdpVideoSurfaceCreate(VdpDevice device, VdpChromaType chroma_type,
  56                         uint32_t width, uint32_t height,
  57                         VdpVideoSurface *surface)
  58 {
  59    struct pipe_context *pipe;
  60    vlVdpSurface *p_surf;
  61    VdpStatus ret;
  62
  63    if (!(width && height)) {
  64       ret = VDP_STATUS_INVALID_SIZE;
  65       goto inv_size;
  66    }
  67
  68    p_surf = CALLOC(1, sizeof(vlVdpSurface));
  69    if (!p_surf) {
  70       ret = VDP_STATUS_RESOURCES;
  71       goto no_res;
  72    }
  73
  74    vlVdpDevice *dev = vlGetDataHTAB(device);
  75    if (!dev) {
  76       ret = VDP_STATUS_INVALID_HANDLE;
  77       goto inv_device;
  78    }
  79
  80    DeviceReference(&p_surf->device, dev);
  81    pipe = dev->context;
  82
  83    pipe_mutex_lock(dev->mutex);
  84    memset(&p_surf->templat, 0, sizeof(p_surf->templat));
  85    p_surf->templat.buffer_format = pipe->screen->get_video_param
  86    (
  87       pipe->screen,
  88       PIPE_VIDEO_PROFILE_UNKNOWN,
  89       PIPE_VIDEO_ENTRYPOINT_BITSTREAM,
  90       PIPE_VIDEO_CAP_PREFERED_FORMAT
  91    );
  92    p_surf->templat.chroma_format = ChromaToPipe(chroma_type);
  93    p_surf->templat.width = width;
  94    p_surf->templat.height = height;
  95    p_surf->templat.interlaced = pipe->screen->get_video_param
  96    (
  97       pipe->screen,
  98       PIPE_VIDEO_PROFILE_UNKNOWN,
  99       PIPE_VIDEO_ENTRYPOINT_BITSTREAM,
 100       PIPE_VIDEO_CAP_PREFERS_INTERLACED
 101    );
 102    if (p_surf->templat.buffer_format != PIPE_FORMAT_NONE)
 103       p_surf->video_buffer = pipe->create_video_buffer(pipe, &p_surf->templat);
 104
 105    /* do not mandate early allocation of a video buffer */
 106    vlVdpVideoSurfaceClear(p_surf);
 107    pipe_mutex_unlock(dev->mutex);
 108
 109    *surface = vlAddDataHTAB(p_surf);
 110    if (*surface == 0) {
 111       ret = VDP_STATUS_ERROR;
 112       goto no_handle;
 113    }
 114
 115    return VDP_STATUS_OK;
 116
 117 no_handle:
 118    p_surf->video_buffer->destroy(p_surf->video_buffer);
 119
 120 inv_device:
 121    DeviceReference(&p_surf->device, NULL);
 122    FREE(p_surf);
 123
 124 no_res:
 125 inv_size:
 126    return ret;
 127 }
 128
 129 /**
 130  * Destroy a VdpVideoSurface.
 131  */
 132 VdpStatus
 133 vlVdpVideoSurfaceDestroy(VdpVideoSurface surface)
 134 {
 135    vlVdpSurface *p_surf;
 136
 137    p_surf = (vlVdpSurface *)vlGetDataHTAB((vlHandle)surface);
 138    if (!p_surf)
 139       return VDP_STATUS_INVALID_HANDLE;
 140
 141    pipe_mutex_lock(p_surf->device->mutex);
 142    if (p_surf->video_buffer)
 143       p_surf->video_buffer->destroy(p_surf->video_buffer);
 144    pipe_mutex_unlock(p_surf->device->mutex);
 145
 146    vlRemoveDataHTAB(surface);
 147    DeviceReference(&p_surf->device, NULL);
 148    FREE(p_surf);
 149
 150    return VDP_STATUS_OK;
 151 }
 152
 153 /**
 154  * Retrieve the parameters used to create a VdpVideoSurface.
 155  */
 156 VdpStatus
 157 vlVdpVideoSurfaceGetParameters(VdpVideoSurface surface,
 158                                VdpChromaType *chroma_type,
 159                                uint32_t *width, uint32_t *height)
 160 {
 161    if (!(width && height && chroma_type))
 162       return VDP_STATUS_INVALID_POINTER;
 163
 164    vlVdpSurface *p_surf = vlGetDataHTAB(surface);
 165    if (!p_surf)
 166       return VDP_STATUS_INVALID_HANDLE;
 167
 168    if (p_surf->video_buffer) {
 169       *width = p_surf->video_buffer->width;
 170       *height = p_surf->video_buffer->height;
 171       *chroma_type = PipeToChroma(p_surf->video_buffer->chroma_format);
 172    } else {
 173       *width = p_surf->templat.width;
 174       *height = p_surf->templat.height;
 175       *chroma_type = PipeToChroma(p_surf->templat.chroma_format);
 176    }
 177
 178    return VDP_STATUS_OK;
 179 }
 180
 181 static void
 182 vlVdpVideoSurfaceSize(vlVdpSurface *p_surf, int component,
 183                       unsigned *width, unsigned *height)
 184 {
 185    *width = p_surf->templat.width;
 186    *height = p_surf->templat.height;
 187
 188    vl_video_buffer_adjust_size(width, height, component,
 189                                p_surf->templat.chroma_format,
 190                                p_surf->templat.interlaced);
 191 }
 192
 193 /**
 194  * Copy image data from a VdpVideoSurface to application memory in a specified
 195  * YCbCr format.
 196  */
 197 VdpStatus
 198 vlVdpVideoSurfaceGetBitsYCbCr(VdpVideoSurface surface,
 199                               VdpYCbCrFormat destination_ycbcr_format,
 200                               void *const *destination_data,
 201                               uint32_t const *destination_pitches)
 202 {
 203    vlVdpSurface *vlsurface;
 204    struct pipe_context *pipe;
 205    enum pipe_format format, buffer_format;
 206    struct pipe_sampler_view **sampler_views;
 207    enum getbits_conversion conversion = CONVERSION_NONE;
 208    unsigned i, j;
 209
 210    vlsurface = vlGetDataHTAB(surface);
 211    if (!vlsurface)
 212       return VDP_STATUS_INVALID_HANDLE;
 213
 214    pipe = vlsurface->device->context;
 215    if (!pipe)
 216       return VDP_STATUS_INVALID_HANDLE;
 217
 218    if (!destination_data || !destination_pitches)
 219        return VDP_STATUS_INVALID_POINTER;
 220
 221    format = FormatYCBCRToPipe(destination_ycbcr_format);
 222    if (format == PIPE_FORMAT_NONE)
 223       return VDP_STATUS_INVALID_Y_CB_CR_FORMAT;
 224
 225    if (vlsurface->video_buffer == NULL)
 226       return VDP_STATUS_INVALID_VALUE;
 227
 228    buffer_format = vlsurface->video_buffer->buffer_format;
 229    if (format != buffer_format) {
 230       if (format == PIPE_FORMAT_YV12 && buffer_format == PIPE_FORMAT_NV12)
 231          conversion = CONVERSION_NV12_TO_YV12;
 232       else if (format == PIPE_FORMAT_NV12 && buffer_format == PIPE_FORMAT_YV12)
 233          conversion = CONVERSION_YV12_TO_NV12;
 234       else if ((format == PIPE_FORMAT_YUYV && buffer_format == PIPE_FORMAT_UYVY) ||
 235                (format == PIPE_FORMAT_UYVY && buffer_format == PIPE_FORMAT_YUYV))
 236          conversion = CONVERSION_SWAP_YUYV_UYVY;
 237       else
 238          return VDP_STATUS_NO_IMPLEMENTATION;
 239    }
 240
 241    pipe_mutex_lock(vlsurface->device->mutex);
 242    sampler_views = vlsurface->video_buffer->get_sampler_view_planes(vlsurface->video_buffer);
 243    if (!sampler_views) {
 244       pipe_mutex_unlock(vlsurface->device->mutex);
 245       return VDP_STATUS_RESOURCES;
 246    }
 247
 248    for (i = 0; i < 3; ++i) {
 249       unsigned width, height;
 250       struct pipe_sampler_view *sv = sampler_views[i];
 251       if (!sv) continue;
 252
 253       vlVdpVideoSurfaceSize(vlsurface, i, &width, &height);
 254
 255       for (j = 0; j < sv->texture->array_size; ++j) {
 256          struct pipe_box box = {
 257             0, 0, j,
 258             width, height, 1
 259          };
 260          struct pipe_transfer *transfer;
 261          uint8_t *map;
 262
 263          map = pipe->transfer_map(pipe, sv->texture, 0,
 264                                        PIPE_TRANSFER_READ, &box, &transfer);
 265          if (!map) {
 266             pipe_mutex_unlock(vlsurface->device->mutex);
 267             return VDP_STATUS_RESOURCES;
 268          }
 269
 270          if (conversion == CONVERSION_NV12_TO_YV12 && i == 1) {
 271             u_copy_nv12_to_yv12(destination_data, destination_pitches,
 272                                 i, j, transfer->stride, sv->texture->array_size,
 273                                 map, box.width, box.height);
 274          } else if (conversion == CONVERSION_YV12_TO_NV12 && i > 0) {
 275             u_copy_yv12_to_nv12(destination_data, destination_pitches,
 276                                 i, j, transfer->stride, sv->texture->array_size,
 277                                 map, box.width, box.height);
 278          } else if (conversion == CONVERSION_SWAP_YUYV_UYVY) {
 279             u_copy_swap422_packed(destination_data, destination_pitches,
 280                                    i, j, transfer->stride, sv->texture->array_size,
 281                                    map, box.width, box.height);
 282          } else {
 283             util_copy_rect(destination_data[i] + destination_pitches[i] * j, sv->texture->format,
 284                            destination_pitches[i] * sv->texture->array_size, 0, 0,
 285                            box.width, box.height, map, transfer->stride, 0, 0);
 286          }
 287
 288          pipe_transfer_unmap(pipe, transfer);
 289       }
 290    }
 291    pipe_mutex_unlock(vlsurface->device->mutex);
 292
 293    return VDP_STATUS_OK;
 294 }
 295
 296 /**
 297  * Copy image data from application memory in a specific YCbCr format to
 298  * a VdpVideoSurface.
 299  */
 300 VdpStatus
 301 vlVdpVideoSurfacePutBitsYCbCr(VdpVideoSurface surface,
 302                               VdpYCbCrFormat source_ycbcr_format,
 303                               void const *const *source_data,
 304                               uint32_t const *source_pitches)
 305 {
 306    enum pipe_format pformat = FormatYCBCRToPipe(source_ycbcr_format);
 307    struct pipe_context *pipe;
 308    struct pipe_sampler_view **sampler_views;
 309    unsigned i, j;
 310
 311    vlVdpSurface *p_surf = vlGetDataHTAB(surface);
 312    if (!p_surf)
 313       return VDP_STATUS_INVALID_HANDLE;
 314
 315    pipe = p_surf->device->context;
 316    if (!pipe)
 317       return VDP_STATUS_INVALID_HANDLE;
 318
 319    if (!source_data || !source_pitches)
 320        return VDP_STATUS_INVALID_POINTER;
 321
 322    pipe_mutex_lock(p_surf->device->mutex);
 323    if (p_surf->video_buffer == NULL || pformat != p_surf->video_buffer->buffer_format) {
 324
 325       /* destroy the old one */
 326       if (p_surf->video_buffer)
 327          p_surf->video_buffer->destroy(p_surf->video_buffer);
 328
 329       /* adjust the template parameters */
 330       p_surf->templat.buffer_format = pformat;
 331
 332       /* and try to create the video buffer with the new format */
 333       p_surf->video_buffer = pipe->create_video_buffer(pipe, &p_surf->templat);
 334
 335       /* stil no luck? ok forget it we don't support it */
 336       if (!p_surf->video_buffer) {
 337          pipe_mutex_unlock(p_surf->device->mutex);
 338          return VDP_STATUS_NO_IMPLEMENTATION;
 339       }
 340       vlVdpVideoSurfaceClear(p_surf);
 341    }
 342
 343    sampler_views = p_surf->video_buffer->get_sampler_view_planes(p_surf->video_buffer);
 344    if (!sampler_views) {
 345       pipe_mutex_unlock(p_surf->device->mutex);
 346       return VDP_STATUS_RESOURCES;
 347    }
 348
 349    for (i = 0; i < 3; ++i) {
 350       unsigned width, height;
 351       struct pipe_sampler_view *sv = sampler_views[i];
 352       if (!sv || !source_pitches[i]) continue;
 353
 354       vlVdpVideoSurfaceSize(p_surf, i, &width, &height);
 355
 356       for (j = 0; j < sv->texture->array_size; ++j) {
 357          struct pipe_box dst_box = {
 358             0, 0, j,
 359             width, height, 1
 360          };
 361
 362          pipe->transfer_inline_write(pipe, sv->texture, 0,
 363                                      PIPE_TRANSFER_WRITE, &dst_box,
 364                                      source_data[i] + source_pitches[i] * j,
 365                                      source_pitches[i] * sv->texture->array_size,
 366                                      0);
 367       }
 368    }
 369    pipe_mutex_unlock(p_surf->device->mutex);
 370
 371    return VDP_STATUS_OK;
 372 }
 373
 374 /**
 375  * Helper function to initially clear the VideoSurface after (re-)creation
 376  */
 377 void
 378 vlVdpVideoSurfaceClear(vlVdpSurface *vlsurf)
 379 {
 380    struct pipe_context *pipe = vlsurf->device->context;
 381    struct pipe_surface **surfaces;
 382    unsigned i;
 383
 384    if (!vlsurf->video_buffer)
 385       return;
 386
 387    surfaces = vlsurf->video_buffer->get_surfaces(vlsurf->video_buffer);
 388    for (i = 0; i < VL_MAX_SURFACES; ++i) {
 389       union pipe_color_union c = {};
 390
 391       if (!surfaces[i])
 392          continue;
 393
 394       if (i > !!vlsurf->templat.interlaced)
 395          c.f[0] = c.f[1] = c.f[2] = c.f[3] = 0.5f;
 396
 397       pipe->clear_render_target(pipe, surfaces[i], &c, 0, 0,
 398                                 surfaces[i]->width, surfaces[i]->height);
 399    }
 400    pipe->flush(pipe, NULL, 0);
 401 }
 402
 403 /**
 404  * Interop to mesa state tracker
 405  */
 406 struct pipe_video_buffer *vlVdpVideoSurfaceGallium(VdpVideoSurface surface)
 407 {
 408    vlVdpSurface *p_surf = vlGetDataHTAB(surface);
 409    if (!p_surf)
 410       return NULL;
 411
 412    pipe_mutex_lock(p_surf->device->mutex);
 413    if (p_surf->video_buffer == NULL) {
 414       struct pipe_context *pipe = p_surf->device->context;
 415
 416       /* try to create a video buffer if we don't already have one */
 417       p_surf->video_buffer = pipe->create_video_buffer(pipe, &p_surf->templat);
 418    }
 419    pipe_mutex_unlock(p_surf->device->mutex);
 420
 421    return p_surf->video_buffer;
 422 }
 423
 424 VdpStatus vlVdpVideoSurfaceDMABuf(VdpVideoSurface surface,
 425                                   VdpVideoSurfacePlane plane,
 426                                   struct VdpSurfaceDMABufDesc *result)
 427 {
 428    vlVdpSurface *p_surf = vlGetDataHTAB(surface);
 429
 430    struct pipe_screen *pscreen;
 431    struct winsys_handle whandle;
 432
 433    struct pipe_surface *surf;
 434
 435    if (!p_surf)
 436       return VDP_STATUS_INVALID_HANDLE;
 437
 438    if (plane > 3)
 439       return VDP_STATUS_INVALID_VALUE;
 440
 441    if (!result)
 442       return VDP_STATUS_INVALID_POINTER;
 443
 444    memset(result, 0, sizeof(*result));
 445    result->handle = -1;
 446
 447    pipe_mutex_lock(p_surf->device->mutex);
 448    if (p_surf->video_buffer == NULL) {
 449       struct pipe_context *pipe = p_surf->device->context;
 450
 451       /* try to create a video buffer if we don't already have one */
 452       p_surf->video_buffer = pipe->create_video_buffer(pipe, &p_surf->templat);
 453    }
 454
 455    /* Check if surface match interop requirements */
 456    if (p_surf->video_buffer == NULL || !p_surf->video_buffer->interlaced ||
 457        p_surf->video_buffer->buffer_format != PIPE_FORMAT_NV12) {
 458       pipe_mutex_unlock(p_surf->device->mutex);
 459       return VDP_STATUS_NO_IMPLEMENTATION;
 460    }
 461
 462    surf = p_surf->video_buffer->get_surfaces(p_surf->video_buffer)[plane];
 463    pipe_mutex_unlock(p_surf->device->mutex);
 464
 465    if (!surf)
 466       return VDP_STATUS_RESOURCES;
 467
 468    memset(&whandle, 0, sizeof(struct winsys_handle));
 469    whandle.type = DRM_API_HANDLE_TYPE_FD;
 470    whandle.layer = surf->u.tex.first_layer;
 471
 472    pscreen = surf->texture->screen;
 473    if (!pscreen->resource_get_handle(pscreen, surf->texture, &whandle,
 474                                      PIPE_HANDLE_USAGE_READ_WRITE))
 475       return VDP_STATUS_NO_IMPLEMENTATION;
 476
 477    result->handle = whandle.handle;
 478    result->width = surf->width;
 479    result->height = surf->height;
 480    result->offset = whandle.offset;
 481    result->stride = whandle.stride;
 482
 483    if (surf->format == PIPE_FORMAT_R8_UNORM)
 484       result->format = VDP_RGBA_FORMAT_R8;
 485    else
 486       result->format = VDP_RGBA_FORMAT_R8G8;
 487
 488    return VDP_STATUS_OK;
 489 }