git.sesse.net Git - ffmpeg/blob - libavutil/hwcontext_vdpau.c

   1 /*
   2  * This file is part of FFmpeg.
   3  *
   4  * FFmpeg is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * FFmpeg is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with FFmpeg; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  17  */
  18
  19 #include "config.h"
  20
  21 #include <stdint.h>
  22 #include <string.h>
  23
  24 #include <vdpau/vdpau.h>
  25
  26 #include "buffer.h"
  27 #include "common.h"
  28 #include "hwcontext.h"
  29 #include "hwcontext_internal.h"
  30 #include "hwcontext_vdpau.h"
  31 #include "mem.h"
  32 #include "pixfmt.h"
  33 #include "pixdesc.h"
  34
  35 typedef struct VDPAUDeviceContext {
  36     VdpVideoSurfaceQueryGetPutBitsYCbCrCapabilities *get_transfer_caps;
  37     VdpVideoSurfaceGetBitsYCbCr                     *get_data;
  38     VdpVideoSurfacePutBitsYCbCr                     *put_data;
  39     VdpVideoSurfaceCreate                           *surf_create;
  40     VdpVideoSurfaceDestroy                          *surf_destroy;
  41
  42     enum AVPixelFormat *pix_fmts[3];
  43     int              nb_pix_fmts[3];
  44 } VDPAUDeviceContext;
  45
  46 typedef struct VDPAUFramesContext {
  47     VdpVideoSurfaceGetBitsYCbCr *get_data;
  48     VdpVideoSurfacePutBitsYCbCr *put_data;
  49     VdpChromaType chroma_type;
  50     int chroma_idx;
  51
  52     const enum AVPixelFormat *pix_fmts;
  53     int                       nb_pix_fmts;
  54 } VDPAUFramesContext;
  55
  56 typedef struct VDPAUPixFmtMap {
  57     VdpYCbCrFormat vdpau_fmt;
  58     enum AVPixelFormat pix_fmt;
  59 } VDPAUPixFmtMap;
  60
  61 static const VDPAUPixFmtMap pix_fmts_420[] = {
  62     { VDP_YCBCR_FORMAT_NV12, AV_PIX_FMT_NV12    },
  63     { VDP_YCBCR_FORMAT_YV12, AV_PIX_FMT_YUV420P },
  64     { 0,                     AV_PIX_FMT_NONE,   },
  65 };
  66
  67 static const VDPAUPixFmtMap pix_fmts_422[] = {
  68     { VDP_YCBCR_FORMAT_NV12, AV_PIX_FMT_NV16    },
  69     { VDP_YCBCR_FORMAT_YV12, AV_PIX_FMT_YUV422P },
  70     { VDP_YCBCR_FORMAT_UYVY, AV_PIX_FMT_UYVY422 },
  71     { VDP_YCBCR_FORMAT_YUYV, AV_PIX_FMT_YUYV422 },
  72     { 0,                     AV_PIX_FMT_NONE,   },
  73 };
  74
  75 static const VDPAUPixFmtMap pix_fmts_444[] = {
  76     { VDP_YCBCR_FORMAT_YV12, AV_PIX_FMT_YUV444P },
  77     { 0,                     AV_PIX_FMT_NONE,   },
  78 };
  79
  80 static const struct {
  81     VdpChromaType chroma_type;
  82     enum AVPixelFormat frames_sw_format;
  83     const VDPAUPixFmtMap *map;
  84 } vdpau_pix_fmts[] = {
  85     { VDP_CHROMA_TYPE_420, AV_PIX_FMT_YUV420P, pix_fmts_420 },
  86     { VDP_CHROMA_TYPE_422, AV_PIX_FMT_YUV422P, pix_fmts_422 },
  87     { VDP_CHROMA_TYPE_444, AV_PIX_FMT_YUV444P, pix_fmts_444 },
  88 };
  89
  90 static int count_pixfmts(const VDPAUPixFmtMap *map)
  91 {
  92     int count = 0;
  93     while (map->pix_fmt != AV_PIX_FMT_NONE) {
  94         map++;
  95         count++;
  96     }
  97     return count;
  98 }
  99
 100 static int vdpau_init_pixmfts(AVHWDeviceContext *ctx)
 101 {
 102     AVVDPAUDeviceContext *hwctx = ctx->hwctx;
 103     VDPAUDeviceContext    *priv = ctx->internal->priv;
 104     int i;
 105
 106     for (i = 0; i < FF_ARRAY_ELEMS(priv->pix_fmts); i++) {
 107         const VDPAUPixFmtMap *map = vdpau_pix_fmts[i].map;
 108         int nb_pix_fmts;
 109
 110         nb_pix_fmts = count_pixfmts(map);
 111         priv->pix_fmts[i] = av_malloc_array(nb_pix_fmts + 1, sizeof(*priv->pix_fmts[i]));
 112         if (!priv->pix_fmts[i])
 113             return AVERROR(ENOMEM);
 114
 115         nb_pix_fmts = 0;
 116         while (map->pix_fmt != AV_PIX_FMT_NONE) {
 117             VdpBool supported;
 118             VdpStatus err = priv->get_transfer_caps(hwctx->device, vdpau_pix_fmts[i].chroma_type,
 119                                                     map->vdpau_fmt, &supported);
 120             if (err == VDP_STATUS_OK && supported)
 121                 priv->pix_fmts[i][nb_pix_fmts++] = map->pix_fmt;
 122             map++;
 123         }
 124         priv->pix_fmts[i][nb_pix_fmts++] = AV_PIX_FMT_NONE;
 125         priv->nb_pix_fmts[i]             = nb_pix_fmts;
 126     }
 127
 128     return 0;
 129 }
 130
 131 #define GET_CALLBACK(id, result)                                                \
 132 do {                                                                            \
 133     void *tmp;                                                                  \
 134     err = hwctx->get_proc_address(hwctx->device, id, &tmp);                     \
 135     if (err != VDP_STATUS_OK) {                                                 \
 136         av_log(ctx, AV_LOG_ERROR, "Error getting the " #id " callback.\n");     \
 137         return AVERROR_UNKNOWN;                                                 \
 138     }                                                                           \
 139     result = tmp;                                                               \
 140 } while (0)
 141
 142 static int vdpau_device_init(AVHWDeviceContext *ctx)
 143 {
 144     AVVDPAUDeviceContext *hwctx = ctx->hwctx;
 145     VDPAUDeviceContext   *priv  = ctx->internal->priv;
 146     VdpStatus             err;
 147     int                   ret;
 148
 149     GET_CALLBACK(VDP_FUNC_ID_VIDEO_SURFACE_QUERY_GET_PUT_BITS_Y_CB_CR_CAPABILITIES,
 150                  priv->get_transfer_caps);
 151     GET_CALLBACK(VDP_FUNC_ID_VIDEO_SURFACE_GET_BITS_Y_CB_CR, priv->get_data);
 152     GET_CALLBACK(VDP_FUNC_ID_VIDEO_SURFACE_PUT_BITS_Y_CB_CR, priv->put_data);
 153     GET_CALLBACK(VDP_FUNC_ID_VIDEO_SURFACE_CREATE,           priv->surf_create);
 154     GET_CALLBACK(VDP_FUNC_ID_VIDEO_SURFACE_DESTROY,          priv->surf_destroy);
 155
 156     ret = vdpau_init_pixmfts(ctx);
 157     if (ret < 0) {
 158         av_log(ctx, AV_LOG_ERROR, "Error querying the supported pixel formats\n");
 159         return ret;
 160     }
 161
 162     return 0;
 163 }
 164
 165 static void vdpau_device_uninit(AVHWDeviceContext *ctx)
 166 {
 167     VDPAUDeviceContext *priv = ctx->internal->priv;
 168     int i;
 169
 170     for (i = 0; i < FF_ARRAY_ELEMS(priv->pix_fmts); i++)
 171         av_freep(&priv->pix_fmts[i]);
 172 }
 173
 174 static int vdpau_frames_get_constraints(AVHWDeviceContext *ctx,
 175                                         const void *hwconfig,
 176                                         AVHWFramesConstraints *constraints)
 177 {
 178     VDPAUDeviceContext   *priv  = ctx->internal->priv;
 179     int nb_sw_formats = 0;
 180     int i;
 181
 182     constraints->valid_sw_formats = av_malloc_array(FF_ARRAY_ELEMS(vdpau_pix_fmts) + 1,
 183                                                     sizeof(*constraints->valid_sw_formats));
 184     if (!constraints->valid_sw_formats)
 185         return AVERROR(ENOMEM);
 186
 187     for (i = 0; i < FF_ARRAY_ELEMS(vdpau_pix_fmts); i++) {
 188         if (priv->nb_pix_fmts[i] > 1)
 189             constraints->valid_sw_formats[nb_sw_formats++] = vdpau_pix_fmts[i].frames_sw_format;
 190     }
 191     constraints->valid_sw_formats[nb_sw_formats] = AV_PIX_FMT_NONE;
 192
 193     constraints->valid_hw_formats = av_malloc_array(2, sizeof(*constraints->valid_hw_formats));
 194     if (!constraints->valid_hw_formats)
 195         return AVERROR(ENOMEM);
 196
 197     constraints->valid_hw_formats[0] = AV_PIX_FMT_VDPAU;
 198     constraints->valid_hw_formats[1] = AV_PIX_FMT_NONE;
 199
 200     return 0;
 201 }
 202
 203 static void vdpau_buffer_free(void *opaque, uint8_t *data)
 204 {
 205     AVHWFramesContext          *ctx = opaque;
 206     VDPAUDeviceContext *device_priv = ctx->device_ctx->internal->priv;
 207     VdpVideoSurface            surf = (VdpVideoSurface)(uintptr_t)data;
 208
 209     device_priv->surf_destroy(surf);
 210 }
 211
 212 static AVBufferRef *vdpau_pool_alloc(void *opaque, int size)
 213 {
 214     AVHWFramesContext             *ctx = opaque;
 215     VDPAUFramesContext           *priv = ctx->internal->priv;
 216     AVVDPAUDeviceContext *device_hwctx = ctx->device_ctx->hwctx;
 217     VDPAUDeviceContext    *device_priv = ctx->device_ctx->internal->priv;
 218
 219     AVBufferRef *ret;
 220     VdpVideoSurface surf;
 221     VdpStatus err;
 222
 223     err = device_priv->surf_create(device_hwctx->device, priv->chroma_type,
 224                                    ctx->width, ctx->height, &surf);
 225     if (err != VDP_STATUS_OK) {
 226         av_log(ctx, AV_LOG_ERROR, "Error allocating a VDPAU video surface\n");
 227         return NULL;
 228     }
 229
 230     ret = av_buffer_create((uint8_t*)(uintptr_t)surf, sizeof(surf),
 231                            vdpau_buffer_free, ctx, AV_BUFFER_FLAG_READONLY);
 232     if (!ret) {
 233         device_priv->surf_destroy(surf);
 234         return NULL;
 235     }
 236
 237     return ret;
 238 }
 239
 240 static int vdpau_frames_init(AVHWFramesContext *ctx)
 241 {
 242     VDPAUDeviceContext *device_priv = ctx->device_ctx->internal->priv;
 243     VDPAUFramesContext        *priv = ctx->internal->priv;
 244
 245     int i;
 246
 247     for (i = 0; i < FF_ARRAY_ELEMS(vdpau_pix_fmts); i++) {
 248         if (vdpau_pix_fmts[i].frames_sw_format == ctx->sw_format) {
 249             priv->chroma_type = vdpau_pix_fmts[i].chroma_type;
 250             priv->chroma_idx  = i;
 251             priv->pix_fmts    = device_priv->pix_fmts[i];
 252             priv->nb_pix_fmts = device_priv->nb_pix_fmts[i];
 253             break;
 254         }
 255     }
 256     if (priv->nb_pix_fmts < 2) {
 257         av_log(ctx, AV_LOG_ERROR, "Unsupported sw format: %s\n",
 258                av_get_pix_fmt_name(ctx->sw_format));
 259         return AVERROR(ENOSYS);
 260     }
 261
 262     if (!ctx->pool) {
 263         ctx->internal->pool_internal = av_buffer_pool_init2(sizeof(VdpVideoSurface), ctx,
 264                                                             vdpau_pool_alloc, NULL);
 265         if (!ctx->internal->pool_internal)
 266             return AVERROR(ENOMEM);
 267     }
 268
 269     priv->get_data = device_priv->get_data;
 270     priv->put_data = device_priv->put_data;
 271
 272     return 0;
 273 }
 274
 275 static int vdpau_get_buffer(AVHWFramesContext *ctx, AVFrame *frame)
 276 {
 277     frame->buf[0] = av_buffer_pool_get(ctx->pool);
 278     if (!frame->buf[0])
 279         return AVERROR(ENOMEM);
 280
 281     frame->data[3] = frame->buf[0]->data;
 282     frame->format  = AV_PIX_FMT_VDPAU;
 283     frame->width   = ctx->width;
 284     frame->height  = ctx->height;
 285
 286     return 0;
 287 }
 288
 289 static int vdpau_transfer_get_formats(AVHWFramesContext *ctx,
 290                                       enum AVHWFrameTransferDirection dir,
 291                                       enum AVPixelFormat **formats)
 292 {
 293     VDPAUFramesContext *priv  = ctx->internal->priv;
 294
 295     enum AVPixelFormat *fmts;
 296
 297     if (priv->nb_pix_fmts == 1) {
 298         av_log(ctx, AV_LOG_ERROR,
 299                "No target formats are supported for this chroma type\n");
 300         return AVERROR(ENOSYS);
 301     }
 302
 303     fmts = av_malloc_array(priv->nb_pix_fmts, sizeof(*fmts));
 304     if (!fmts)
 305         return AVERROR(ENOMEM);
 306
 307     memcpy(fmts, priv->pix_fmts, sizeof(*fmts) * (priv->nb_pix_fmts));
 308     *formats = fmts;
 309
 310     return 0;
 311 }
 312
 313 static int vdpau_transfer_data_from(AVHWFramesContext *ctx, AVFrame *dst,
 314                                     const AVFrame *src)
 315 {
 316     VDPAUFramesContext *priv = ctx->internal->priv;
 317     VdpVideoSurface     surf = (VdpVideoSurface)(uintptr_t)src->data[3];
 318
 319     void *data[3];
 320     uint32_t linesize[3];
 321
 322     const VDPAUPixFmtMap *map;
 323     VdpYCbCrFormat vdpau_format;
 324     VdpStatus err;
 325     int i;
 326
 327     for (i = 0; i< FF_ARRAY_ELEMS(data) && dst->data[i]; i++) {
 328         data[i] = dst->data[i];
 329         if (dst->linesize[i] < 0 || dst->linesize[i] > UINT32_MAX) {
 330             av_log(ctx, AV_LOG_ERROR,
 331                    "The linesize %d cannot be represented as uint32\n",
 332                    dst->linesize[i]);
 333             return AVERROR(ERANGE);
 334         }
 335         linesize[i] = dst->linesize[i];
 336     }
 337
 338     map = vdpau_pix_fmts[priv->chroma_idx].map;
 339     for (i = 0; map[i].pix_fmt != AV_PIX_FMT_NONE; i++) {
 340         if (map[i].pix_fmt == dst->format) {
 341             vdpau_format = map[i].vdpau_fmt;
 342             break;
 343         }
 344     }
 345     if (map[i].pix_fmt == AV_PIX_FMT_NONE) {
 346         av_log(ctx, AV_LOG_ERROR,
 347                "Unsupported target pixel format: %s\n",
 348                av_get_pix_fmt_name(dst->format));
 349         return AVERROR(EINVAL);
 350     }
 351
 352     if (vdpau_format == VDP_YCBCR_FORMAT_YV12)
 353         FFSWAP(void*, data[1], data[2]);
 354
 355     err = priv->get_data(surf, vdpau_format, data, linesize);
 356     if (err != VDP_STATUS_OK) {
 357         av_log(ctx, AV_LOG_ERROR, "Error retrieving the data from a VDPAU surface\n");
 358         return AVERROR_UNKNOWN;
 359     }
 360
 361     return 0;
 362 }
 363
 364 static int vdpau_transfer_data_to(AVHWFramesContext *ctx, AVFrame *dst,
 365                                   const AVFrame *src)
 366 {
 367     VDPAUFramesContext *priv = ctx->internal->priv;
 368     VdpVideoSurface     surf = (VdpVideoSurface)(uintptr_t)dst->data[3];
 369
 370     const void *data[3];
 371     uint32_t linesize[3];
 372
 373     const VDPAUPixFmtMap *map;
 374     VdpYCbCrFormat vdpau_format;
 375     VdpStatus err;
 376     int i;
 377
 378     for (i = 0; i< FF_ARRAY_ELEMS(data) && src->data[i]; i++) {
 379         data[i] = src->data[i];
 380         if (src->linesize[i] < 0 || src->linesize[i] > UINT32_MAX) {
 381             av_log(ctx, AV_LOG_ERROR,
 382                    "The linesize %d cannot be represented as uint32\n",
 383                    src->linesize[i]);
 384             return AVERROR(ERANGE);
 385         }
 386         linesize[i] = src->linesize[i];
 387     }
 388
 389     map = vdpau_pix_fmts[priv->chroma_idx].map;
 390     for (i = 0; map[i].pix_fmt != AV_PIX_FMT_NONE; i++) {
 391         if (map[i].pix_fmt == src->format) {
 392             vdpau_format = map[i].vdpau_fmt;
 393             break;
 394         }
 395     }
 396     if (map[i].pix_fmt == AV_PIX_FMT_NONE) {
 397         av_log(ctx, AV_LOG_ERROR,
 398                "Unsupported source pixel format: %s\n",
 399                av_get_pix_fmt_name(src->format));
 400         return AVERROR(EINVAL);
 401     }
 402
 403     if (vdpau_format == VDP_YCBCR_FORMAT_YV12)
 404         FFSWAP(const void*, data[1], data[2]);
 405
 406     err = priv->put_data(surf, vdpau_format, data, linesize);
 407     if (err != VDP_STATUS_OK) {
 408         av_log(ctx, AV_LOG_ERROR, "Error uploading the data to a VDPAU surface\n");
 409         return AVERROR_UNKNOWN;
 410     }
 411
 412     return 0;
 413 }
 414
 415 #if HAVE_VDPAU_X11
 416 #include <vdpau/vdpau_x11.h>
 417 #include <X11/Xlib.h>
 418
 419 typedef struct VDPAUDevicePriv {
 420     VdpDeviceDestroy *device_destroy;
 421     Display *dpy;
 422 } VDPAUDevicePriv;
 423
 424 static void vdpau_device_free(AVHWDeviceContext *ctx)
 425 {
 426     AVVDPAUDeviceContext *hwctx = ctx->hwctx;
 427     VDPAUDevicePriv       *priv = ctx->user_opaque;
 428
 429     if (priv->device_destroy)
 430         priv->device_destroy(hwctx->device);
 431     if (priv->dpy)
 432         XCloseDisplay(priv->dpy);
 433     av_freep(&priv);
 434 }
 435
 436 static int vdpau_device_create(AVHWDeviceContext *ctx, const char *device,
 437                                AVDictionary *opts, int flags)
 438 {
 439     AVVDPAUDeviceContext *hwctx = ctx->hwctx;
 440
 441     VDPAUDevicePriv *priv;
 442     VdpStatus err;
 443     VdpGetInformationString *get_information_string;
 444     const char *display, *vendor;
 445
 446     priv = av_mallocz(sizeof(*priv));
 447     if (!priv)
 448         return AVERROR(ENOMEM);
 449
 450     ctx->user_opaque = priv;
 451     ctx->free        = vdpau_device_free;
 452
 453     priv->dpy = XOpenDisplay(device);
 454     if (!priv->dpy) {
 455         av_log(ctx, AV_LOG_ERROR, "Cannot open the X11 display %s.\n",
 456                XDisplayName(device));
 457         return AVERROR_UNKNOWN;
 458     }
 459     display = XDisplayString(priv->dpy);
 460
 461     err = vdp_device_create_x11(priv->dpy, XDefaultScreen(priv->dpy),
 462                                 &hwctx->device, &hwctx->get_proc_address);
 463     if (err != VDP_STATUS_OK) {
 464         av_log(ctx, AV_LOG_ERROR, "VDPAU device creation on X11 display %s failed.\n",
 465                display);
 466         return AVERROR_UNKNOWN;
 467     }
 468
 469     GET_CALLBACK(VDP_FUNC_ID_GET_INFORMATION_STRING, get_information_string);
 470     GET_CALLBACK(VDP_FUNC_ID_DEVICE_DESTROY,         priv->device_destroy);
 471
 472     get_information_string(&vendor);
 473     av_log(ctx, AV_LOG_VERBOSE, "Successfully created a VDPAU device (%s) on "
 474            "X11 display %s\n", vendor, display);
 475
 476     return 0;
 477 }
 478 #endif
 479
 480 const HWContextType ff_hwcontext_type_vdpau = {
 481     .type                 = AV_HWDEVICE_TYPE_VDPAU,
 482     .name                 = "VDPAU",
 483
 484     .device_hwctx_size    = sizeof(AVVDPAUDeviceContext),
 485     .device_priv_size     = sizeof(VDPAUDeviceContext),
 486     .frames_priv_size     = sizeof(VDPAUFramesContext),
 487
 488 #if HAVE_VDPAU_X11
 489     .device_create        = vdpau_device_create,
 490 #endif
 491     .device_init          = vdpau_device_init,
 492     .device_uninit        = vdpau_device_uninit,
 493     .frames_get_constraints = vdpau_frames_get_constraints,
 494     .frames_init          = vdpau_frames_init,
 495     .frames_get_buffer    = vdpau_get_buffer,
 496     .transfer_get_formats = vdpau_transfer_get_formats,
 497     .transfer_data_to     = vdpau_transfer_data_to,
 498     .transfer_data_from   = vdpau_transfer_data_from,
 499
 500     .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU, AV_PIX_FMT_NONE },
 501 };