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 #ifdef VDP_YCBCR_FORMAT_Y_U_V_444
77 { VDP_YCBCR_FORMAT_Y_U_V_444, AV_PIX_FMT_YUV444P },
78 #endif
79 { 0, AV_PIX_FMT_NONE, },
80 };
81
82 static const struct {
83 VdpChromaType chroma_type;
84 enum AVPixelFormat frames_sw_format;
85 const VDPAUPixFmtMap *map;
86 } vdpau_pix_fmts[] = {
87 { VDP_CHROMA_TYPE_420, AV_PIX_FMT_YUV420P, pix_fmts_420 },
88 { VDP_CHROMA_TYPE_422, AV_PIX_FMT_YUV422P, pix_fmts_422 },
89 { VDP_CHROMA_TYPE_444, AV_PIX_FMT_YUV444P, pix_fmts_444 },
90 };
91
count_pixfmts(const VDPAUPixFmtMap * map)92 static int count_pixfmts(const VDPAUPixFmtMap *map)
93 {
94 int count = 0;
95 while (map->pix_fmt != AV_PIX_FMT_NONE) {
96 map++;
97 count++;
98 }
99 return count;
100 }
101
vdpau_init_pixmfts(AVHWDeviceContext * ctx)102 static int vdpau_init_pixmfts(AVHWDeviceContext *ctx)
103 {
104 AVVDPAUDeviceContext *hwctx = ctx->hwctx;
105 VDPAUDeviceContext *priv = ctx->internal->priv;
106 int i;
107
108 for (i = 0; i < FF_ARRAY_ELEMS(priv->pix_fmts); i++) {
109 const VDPAUPixFmtMap *map = vdpau_pix_fmts[i].map;
110 int nb_pix_fmts;
111
112 nb_pix_fmts = count_pixfmts(map);
113 priv->pix_fmts[i] = av_malloc_array(nb_pix_fmts + 1, sizeof(*priv->pix_fmts[i]));
114 if (!priv->pix_fmts[i])
115 return AVERROR(ENOMEM);
116
117 nb_pix_fmts = 0;
118 while (map->pix_fmt != AV_PIX_FMT_NONE) {
119 VdpBool supported;
120 VdpStatus err = priv->get_transfer_caps(hwctx->device, vdpau_pix_fmts[i].chroma_type,
121 map->vdpau_fmt, &supported);
122 if (err == VDP_STATUS_OK && supported)
123 priv->pix_fmts[i][nb_pix_fmts++] = map->pix_fmt;
124 map++;
125 }
126 priv->pix_fmts[i][nb_pix_fmts++] = AV_PIX_FMT_NONE;
127 priv->nb_pix_fmts[i] = nb_pix_fmts;
128 }
129
130 return 0;
131 }
132
133 #define GET_CALLBACK(id, result) \
134 do { \
135 void *tmp; \
136 err = hwctx->get_proc_address(hwctx->device, id, &tmp); \
137 if (err != VDP_STATUS_OK) { \
138 av_log(ctx, AV_LOG_ERROR, "Error getting the " #id " callback.\n"); \
139 return AVERROR_UNKNOWN; \
140 } \
141 result = tmp; \
142 } while (0)
143
vdpau_device_init(AVHWDeviceContext * ctx)144 static int vdpau_device_init(AVHWDeviceContext *ctx)
145 {
146 AVVDPAUDeviceContext *hwctx = ctx->hwctx;
147 VDPAUDeviceContext *priv = ctx->internal->priv;
148 VdpStatus err;
149 int ret;
150
151 GET_CALLBACK(VDP_FUNC_ID_VIDEO_SURFACE_QUERY_GET_PUT_BITS_Y_CB_CR_CAPABILITIES,
152 priv->get_transfer_caps);
153 GET_CALLBACK(VDP_FUNC_ID_VIDEO_SURFACE_GET_BITS_Y_CB_CR, priv->get_data);
154 GET_CALLBACK(VDP_FUNC_ID_VIDEO_SURFACE_PUT_BITS_Y_CB_CR, priv->put_data);
155 GET_CALLBACK(VDP_FUNC_ID_VIDEO_SURFACE_CREATE, priv->surf_create);
156 GET_CALLBACK(VDP_FUNC_ID_VIDEO_SURFACE_DESTROY, priv->surf_destroy);
157
158 ret = vdpau_init_pixmfts(ctx);
159 if (ret < 0) {
160 av_log(ctx, AV_LOG_ERROR, "Error querying the supported pixel formats\n");
161 return ret;
162 }
163
164 return 0;
165 }
166
vdpau_device_uninit(AVHWDeviceContext * ctx)167 static void vdpau_device_uninit(AVHWDeviceContext *ctx)
168 {
169 VDPAUDeviceContext *priv = ctx->internal->priv;
170 int i;
171
172 for (i = 0; i < FF_ARRAY_ELEMS(priv->pix_fmts); i++)
173 av_freep(&priv->pix_fmts[i]);
174 }
175
vdpau_frames_get_constraints(AVHWDeviceContext * ctx,const void * hwconfig,AVHWFramesConstraints * constraints)176 static int vdpau_frames_get_constraints(AVHWDeviceContext *ctx,
177 const void *hwconfig,
178 AVHWFramesConstraints *constraints)
179 {
180 VDPAUDeviceContext *priv = ctx->internal->priv;
181 int nb_sw_formats = 0;
182 int i;
183
184 constraints->valid_sw_formats = av_malloc_array(FF_ARRAY_ELEMS(vdpau_pix_fmts) + 1,
185 sizeof(*constraints->valid_sw_formats));
186 if (!constraints->valid_sw_formats)
187 return AVERROR(ENOMEM);
188
189 for (i = 0; i < FF_ARRAY_ELEMS(vdpau_pix_fmts); i++) {
190 if (priv->nb_pix_fmts[i] > 1)
191 constraints->valid_sw_formats[nb_sw_formats++] = vdpau_pix_fmts[i].frames_sw_format;
192 }
193 constraints->valid_sw_formats[nb_sw_formats] = AV_PIX_FMT_NONE;
194
195 constraints->valid_hw_formats = av_malloc_array(2, sizeof(*constraints->valid_hw_formats));
196 if (!constraints->valid_hw_formats)
197 return AVERROR(ENOMEM);
198
199 constraints->valid_hw_formats[0] = AV_PIX_FMT_VDPAU;
200 constraints->valid_hw_formats[1] = AV_PIX_FMT_NONE;
201
202 return 0;
203 }
204
vdpau_buffer_free(void * opaque,uint8_t * data)205 static void vdpau_buffer_free(void *opaque, uint8_t *data)
206 {
207 AVHWFramesContext *ctx = opaque;
208 VDPAUDeviceContext *device_priv = ctx->device_ctx->internal->priv;
209 VdpVideoSurface surf = (VdpVideoSurface)(uintptr_t)data;
210
211 device_priv->surf_destroy(surf);
212 }
213
vdpau_pool_alloc(void * opaque,int size)214 static AVBufferRef *vdpau_pool_alloc(void *opaque, int size)
215 {
216 AVHWFramesContext *ctx = opaque;
217 VDPAUFramesContext *priv = ctx->internal->priv;
218 AVVDPAUDeviceContext *device_hwctx = ctx->device_ctx->hwctx;
219 VDPAUDeviceContext *device_priv = ctx->device_ctx->internal->priv;
220
221 AVBufferRef *ret;
222 VdpVideoSurface surf;
223 VdpStatus err;
224
225 err = device_priv->surf_create(device_hwctx->device, priv->chroma_type,
226 ctx->width, ctx->height, &surf);
227 if (err != VDP_STATUS_OK) {
228 av_log(ctx, AV_LOG_ERROR, "Error allocating a VDPAU video surface\n");
229 return NULL;
230 }
231
232 ret = av_buffer_create((uint8_t*)(uintptr_t)surf, sizeof(surf),
233 vdpau_buffer_free, ctx, AV_BUFFER_FLAG_READONLY);
234 if (!ret) {
235 device_priv->surf_destroy(surf);
236 return NULL;
237 }
238
239 return ret;
240 }
241
vdpau_frames_init(AVHWFramesContext * ctx)242 static int vdpau_frames_init(AVHWFramesContext *ctx)
243 {
244 VDPAUDeviceContext *device_priv = ctx->device_ctx->internal->priv;
245 VDPAUFramesContext *priv = ctx->internal->priv;
246
247 int i;
248
249 for (i = 0; i < FF_ARRAY_ELEMS(vdpau_pix_fmts); i++) {
250 if (vdpau_pix_fmts[i].frames_sw_format == ctx->sw_format) {
251 priv->chroma_type = vdpau_pix_fmts[i].chroma_type;
252 priv->chroma_idx = i;
253 priv->pix_fmts = device_priv->pix_fmts[i];
254 priv->nb_pix_fmts = device_priv->nb_pix_fmts[i];
255 break;
256 }
257 }
258 if (priv->nb_pix_fmts < 2) {
259 av_log(ctx, AV_LOG_ERROR, "Unsupported sw format: %s\n",
260 av_get_pix_fmt_name(ctx->sw_format));
261 return AVERROR(ENOSYS);
262 }
263
264 if (!ctx->pool) {
265 ctx->internal->pool_internal = av_buffer_pool_init2(sizeof(VdpVideoSurface), ctx,
266 vdpau_pool_alloc, NULL);
267 if (!ctx->internal->pool_internal)
268 return AVERROR(ENOMEM);
269 }
270
271 priv->get_data = device_priv->get_data;
272 priv->put_data = device_priv->put_data;
273
274 return 0;
275 }
276
vdpau_get_buffer(AVHWFramesContext * ctx,AVFrame * frame)277 static int vdpau_get_buffer(AVHWFramesContext *ctx, AVFrame *frame)
278 {
279 frame->buf[0] = av_buffer_pool_get(ctx->pool);
280 if (!frame->buf[0])
281 return AVERROR(ENOMEM);
282
283 frame->data[3] = frame->buf[0]->data;
284 frame->format = AV_PIX_FMT_VDPAU;
285 frame->width = ctx->width;
286 frame->height = ctx->height;
287
288 return 0;
289 }
290
vdpau_transfer_get_formats(AVHWFramesContext * ctx,enum AVHWFrameTransferDirection dir,enum AVPixelFormat ** formats)291 static int vdpau_transfer_get_formats(AVHWFramesContext *ctx,
292 enum AVHWFrameTransferDirection dir,
293 enum AVPixelFormat **formats)
294 {
295 VDPAUFramesContext *priv = ctx->internal->priv;
296
297 enum AVPixelFormat *fmts;
298
299 if (priv->nb_pix_fmts == 1) {
300 av_log(ctx, AV_LOG_ERROR,
301 "No target formats are supported for this chroma type\n");
302 return AVERROR(ENOSYS);
303 }
304
305 fmts = av_malloc_array(priv->nb_pix_fmts, sizeof(*fmts));
306 if (!fmts)
307 return AVERROR(ENOMEM);
308
309 memcpy(fmts, priv->pix_fmts, sizeof(*fmts) * (priv->nb_pix_fmts));
310 *formats = fmts;
311
312 return 0;
313 }
314
vdpau_transfer_data_from(AVHWFramesContext * ctx,AVFrame * dst,const AVFrame * src)315 static int vdpau_transfer_data_from(AVHWFramesContext *ctx, AVFrame *dst,
316 const AVFrame *src)
317 {
318 VDPAUFramesContext *priv = ctx->internal->priv;
319 VdpVideoSurface surf = (VdpVideoSurface)(uintptr_t)src->data[3];
320
321 void *data[3];
322 uint32_t linesize[3];
323
324 const VDPAUPixFmtMap *map;
325 VdpYCbCrFormat vdpau_format;
326 VdpStatus err;
327 int i;
328
329 for (i = 0; i< FF_ARRAY_ELEMS(data) && dst->data[i]; i++) {
330 data[i] = dst->data[i];
331 if (dst->linesize[i] < 0 || dst->linesize[i] > UINT32_MAX) {
332 av_log(ctx, AV_LOG_ERROR,
333 "The linesize %d cannot be represented as uint32\n",
334 dst->linesize[i]);
335 return AVERROR(ERANGE);
336 }
337 linesize[i] = dst->linesize[i];
338 }
339
340 map = vdpau_pix_fmts[priv->chroma_idx].map;
341 for (i = 0; map[i].pix_fmt != AV_PIX_FMT_NONE; i++) {
342 if (map[i].pix_fmt == dst->format) {
343 vdpau_format = map[i].vdpau_fmt;
344 break;
345 }
346 }
347 if (map[i].pix_fmt == AV_PIX_FMT_NONE) {
348 av_log(ctx, AV_LOG_ERROR,
349 "Unsupported target pixel format: %s\n",
350 av_get_pix_fmt_name(dst->format));
351 return AVERROR(EINVAL);
352 }
353
354 if ((vdpau_format == VDP_YCBCR_FORMAT_YV12)
355 #ifdef VDP_YCBCR_FORMAT_Y_U_V_444
356 || (vdpau_format == VDP_YCBCR_FORMAT_Y_U_V_444)
357 #endif
358 )
359 FFSWAP(void*, data[1], data[2]);
360
361 err = priv->get_data(surf, vdpau_format, data, linesize);
362 if (err != VDP_STATUS_OK) {
363 av_log(ctx, AV_LOG_ERROR, "Error retrieving the data from a VDPAU surface\n");
364 return AVERROR_UNKNOWN;
365 }
366
367 return 0;
368 }
369
vdpau_transfer_data_to(AVHWFramesContext * ctx,AVFrame * dst,const AVFrame * src)370 static int vdpau_transfer_data_to(AVHWFramesContext *ctx, AVFrame *dst,
371 const AVFrame *src)
372 {
373 VDPAUFramesContext *priv = ctx->internal->priv;
374 VdpVideoSurface surf = (VdpVideoSurface)(uintptr_t)dst->data[3];
375
376 const void *data[3];
377 uint32_t linesize[3];
378
379 const VDPAUPixFmtMap *map;
380 VdpYCbCrFormat vdpau_format;
381 VdpStatus err;
382 int i;
383
384 for (i = 0; i< FF_ARRAY_ELEMS(data) && src->data[i]; i++) {
385 data[i] = src->data[i];
386 if (src->linesize[i] < 0 || src->linesize[i] > UINT32_MAX) {
387 av_log(ctx, AV_LOG_ERROR,
388 "The linesize %d cannot be represented as uint32\n",
389 src->linesize[i]);
390 return AVERROR(ERANGE);
391 }
392 linesize[i] = src->linesize[i];
393 }
394
395 map = vdpau_pix_fmts[priv->chroma_idx].map;
396 for (i = 0; map[i].pix_fmt != AV_PIX_FMT_NONE; i++) {
397 if (map[i].pix_fmt == src->format) {
398 vdpau_format = map[i].vdpau_fmt;
399 break;
400 }
401 }
402 if (map[i].pix_fmt == AV_PIX_FMT_NONE) {
403 av_log(ctx, AV_LOG_ERROR,
404 "Unsupported source pixel format: %s\n",
405 av_get_pix_fmt_name(src->format));
406 return AVERROR(EINVAL);
407 }
408
409 if ((vdpau_format == VDP_YCBCR_FORMAT_YV12)
410 #ifdef VDP_YCBCR_FORMAT_Y_U_V_444
411 || (vdpau_format == VDP_YCBCR_FORMAT_Y_U_V_444)
412 #endif
413 )
414 FFSWAP(const void*, data[1], data[2]);
415
416 err = priv->put_data(surf, vdpau_format, data, linesize);
417 if (err != VDP_STATUS_OK) {
418 av_log(ctx, AV_LOG_ERROR, "Error uploading the data to a VDPAU surface\n");
419 return AVERROR_UNKNOWN;
420 }
421
422 return 0;
423 }
424
425 #if HAVE_VDPAU_X11
426 #include <vdpau/vdpau_x11.h>
427 #include <X11/Xlib.h>
428
429 typedef struct VDPAUDevicePriv {
430 VdpDeviceDestroy *device_destroy;
431 Display *dpy;
432 } VDPAUDevicePriv;
433
vdpau_device_free(AVHWDeviceContext * ctx)434 static void vdpau_device_free(AVHWDeviceContext *ctx)
435 {
436 AVVDPAUDeviceContext *hwctx = ctx->hwctx;
437 VDPAUDevicePriv *priv = ctx->user_opaque;
438
439 if (priv->device_destroy)
440 priv->device_destroy(hwctx->device);
441 if (priv->dpy)
442 XCloseDisplay(priv->dpy);
443 av_freep(&priv);
444 }
445
vdpau_device_create(AVHWDeviceContext * ctx,const char * device,AVDictionary * opts,int flags)446 static int vdpau_device_create(AVHWDeviceContext *ctx, const char *device,
447 AVDictionary *opts, int flags)
448 {
449 AVVDPAUDeviceContext *hwctx = ctx->hwctx;
450
451 VDPAUDevicePriv *priv;
452 VdpStatus err;
453 VdpGetInformationString *get_information_string;
454 const char *display, *vendor;
455
456 priv = av_mallocz(sizeof(*priv));
457 if (!priv)
458 return AVERROR(ENOMEM);
459
460 ctx->user_opaque = priv;
461 ctx->free = vdpau_device_free;
462
463 priv->dpy = XOpenDisplay(device);
464 if (!priv->dpy) {
465 av_log(ctx, AV_LOG_ERROR, "Cannot open the X11 display %s.\n",
466 XDisplayName(device));
467 return AVERROR_UNKNOWN;
468 }
469 display = XDisplayString(priv->dpy);
470
471 err = vdp_device_create_x11(priv->dpy, XDefaultScreen(priv->dpy),
472 &hwctx->device, &hwctx->get_proc_address);
473 if (err != VDP_STATUS_OK) {
474 av_log(ctx, AV_LOG_ERROR, "VDPAU device creation on X11 display %s failed.\n",
475 display);
476 return AVERROR_UNKNOWN;
477 }
478
479 GET_CALLBACK(VDP_FUNC_ID_GET_INFORMATION_STRING, get_information_string);
480 GET_CALLBACK(VDP_FUNC_ID_DEVICE_DESTROY, priv->device_destroy);
481
482 get_information_string(&vendor);
483 av_log(ctx, AV_LOG_VERBOSE, "Successfully created a VDPAU device (%s) on "
484 "X11 display %s\n", vendor, display);
485
486 return 0;
487 }
488 #endif
489
490 const HWContextType ff_hwcontext_type_vdpau = {
491 .type = AV_HWDEVICE_TYPE_VDPAU,
492 .name = "VDPAU",
493
494 .device_hwctx_size = sizeof(AVVDPAUDeviceContext),
495 .device_priv_size = sizeof(VDPAUDeviceContext),
496 .frames_priv_size = sizeof(VDPAUFramesContext),
497
498 #if HAVE_VDPAU_X11
499 .device_create = vdpau_device_create,
500 #endif
501 .device_init = vdpau_device_init,
502 .device_uninit = vdpau_device_uninit,
503 .frames_get_constraints = vdpau_frames_get_constraints,
504 .frames_init = vdpau_frames_init,
505 .frames_get_buffer = vdpau_get_buffer,
506 .transfer_get_formats = vdpau_transfer_get_formats,
507 .transfer_data_to = vdpau_transfer_data_to,
508 .transfer_data_from = vdpau_transfer_data_from,
509
510 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU, AV_PIX_FMT_NONE },
511 };
512