libavutil/hwcontext.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 "avassert.h"
  22 #include "buffer.h"
  23 #include "common.h"
  24 #include "hwcontext.h"
  25 #include "hwcontext_internal.h"
  26 #include "imgutils.h"
  27 #include "log.h"
  28 #include "mem.h"
  29 #include "pixdesc.h"
  30 #include "pixfmt.h"
  31
  32 static const HWContextType * const hw_table[] = {
  33 #if CONFIG_CUDA
  34     &ff_hwcontext_type_cuda,
  35 #endif
  36 #if CONFIG_D3D11VA
  37     &ff_hwcontext_type_d3d11va,
  38 #endif
  39 #if CONFIG_D3D12VA
  40     &ff_hwcontext_type_d3d12va,
  41 #endif
  42 #if CONFIG_LIBDRM
  43     &ff_hwcontext_type_drm,
  44 #endif
  45 #if CONFIG_DXVA2
  46     &ff_hwcontext_type_dxva2,
  47 #endif
  48 #if CONFIG_OPENCL
  49     &ff_hwcontext_type_opencl,
  50 #endif
  51 #if CONFIG_QSV
  52     &ff_hwcontext_type_qsv,
  53 #endif
  54 #if CONFIG_VAAPI
  55     &ff_hwcontext_type_vaapi,
  56 #endif
  57 #if CONFIG_VDPAU
  58     &ff_hwcontext_type_vdpau,
  59 #endif
  60 #if CONFIG_VIDEOTOOLBOX
  61     &ff_hwcontext_type_videotoolbox,
  62 #endif
  63 #if CONFIG_MEDIACODEC
  64     &ff_hwcontext_type_mediacodec,
  65 #endif
  66 #if CONFIG_VULKAN
  67     &ff_hwcontext_type_vulkan,
  68 #endif
  69 #if CONFIG_AMF
  70     &ff_hwcontext_type_amf,
  71 #endif
  72 #if CONFIG_OHCODEC
  73     &ff_hwcontext_type_oh,
  74 #endif
  75     NULL,
  76 };
  77
  78 static const char *const hw_type_names[] = {
  79     [AV_HWDEVICE_TYPE_CUDA]   = "cuda",
  80     [AV_HWDEVICE_TYPE_DRM]    = "drm",
  81     [AV_HWDEVICE_TYPE_DXVA2]  = "dxva2",
  82     [AV_HWDEVICE_TYPE_D3D11VA] = "d3d11va",
  83     [AV_HWDEVICE_TYPE_D3D12VA] = "d3d12va",
  84     [AV_HWDEVICE_TYPE_OPENCL] = "opencl",
  85     [AV_HWDEVICE_TYPE_QSV]    = "qsv",
  86     [AV_HWDEVICE_TYPE_VAAPI]  = "vaapi",
  87     [AV_HWDEVICE_TYPE_VDPAU]  = "vdpau",
  88     [AV_HWDEVICE_TYPE_VIDEOTOOLBOX] = "videotoolbox",
  89     [AV_HWDEVICE_TYPE_MEDIACODEC] = "mediacodec",
  90     [AV_HWDEVICE_TYPE_VULKAN] = "vulkan",
  91     [AV_HWDEVICE_TYPE_AMF] = "amf",
  92     [AV_HWDEVICE_TYPE_OHCODEC] = "ohcodec",
  93 };
  94
  95 typedef struct FFHWDeviceContext {
  96     /**
  97      * The public AVHWDeviceContext. See hwcontext.h for it.
  98      */
  99     AVHWDeviceContext p;
 100
 101     const HWContextType *hw_type;
 102
 103     /**
 104      * For a derived device, a reference to the original device
 105      * context it was derived from.
 106      */
 107     AVBufferRef *source_device;
 108 } FFHWDeviceContext;
 109
 110 enum AVHWDeviceType av_hwdevice_find_type_by_name(const char *name)
 111 {
 112     int type;
 113     for (type = 0; type < FF_ARRAY_ELEMS(hw_type_names); type++) {
 114         if (hw_type_names[type] && !strcmp(hw_type_names[type], name))
 115             return type;
 116     }
 117     return AV_HWDEVICE_TYPE_NONE;
 118 }
 119
 120 const char *av_hwdevice_get_type_name(enum AVHWDeviceType type)
 121 {
 122     if (type > AV_HWDEVICE_TYPE_NONE &&
 123         type < FF_ARRAY_ELEMS(hw_type_names))
 124         return hw_type_names[type];
 125     else
 126         return NULL;
 127 }
 128
 129 enum AVHWDeviceType av_hwdevice_iterate_types(enum AVHWDeviceType prev)
 130 {
 131     enum AVHWDeviceType next;
 132     int i, set = 0;
 133     for (i = 0; hw_table[i]; i++) {
 134         if (prev != AV_HWDEVICE_TYPE_NONE && hw_table[i]->type <= prev)
 135             continue;
 136         if (!set || hw_table[i]->type < next) {
 137             next = hw_table[i]->type;
 138             set = 1;
 139         }
 140     }
 141     return set ? next : AV_HWDEVICE_TYPE_NONE;
 142 }
 143
 144 static const char *hwdevice_ctx_get_name(void *ptr)
 145 {
 146     FFHWDeviceContext *ctx = ptr;
 147     return ctx->hw_type->name;
 148 }
 149
 150 static const AVClass hwdevice_ctx_class = {
 151     .class_name = "AVHWDeviceContext",
 152     .item_name  = hwdevice_ctx_get_name,
 153     .category   = AV_CLASS_CATEGORY_HWDEVICE,
 154     .version    = LIBAVUTIL_VERSION_INT,
 155 };
 156
 157 static void hwdevice_ctx_free(void *opaque, uint8_t *data)
 158 {
 159     FFHWDeviceContext *ctxi = (FFHWDeviceContext*)data;
 160     AVHWDeviceContext *ctx  = &ctxi->p;
 161
 162     /* uninit might still want access the hw context and the user
 163      * free() callback might destroy it, so uninit has to be called first */
 164     if (ctxi->hw_type->device_uninit)
 165         ctxi->hw_type->device_uninit(ctx);
 166
 167     if (ctx->free)
 168         ctx->free(ctx);
 169
 170     av_buffer_unref(&ctxi->source_device);
 171
 172     av_freep(&ctx->hwctx);
 173     av_freep(&ctx);
 174 }
 175
 176 AVBufferRef *av_hwdevice_ctx_alloc(enum AVHWDeviceType type)
 177 {
 178     FFHWDeviceContext *ctxi;
 179     AVHWDeviceContext *ctx;
 180     AVBufferRef *buf;
 181     const HWContextType *hw_type = NULL;
 182     int i;
 183
 184     for (i = 0; hw_table[i]; i++) {
 185         if (hw_table[i]->type == type) {
 186             hw_type = hw_table[i];
 187             break;
 188         }
 189     }
 190     if (!hw_type)
 191         return NULL;
 192
 193     ctxi = av_mallocz(sizeof(*ctxi));
 194     if (!ctxi)
 195         return NULL;
 196     ctx = &ctxi->p;
 197
 198     if (hw_type->device_hwctx_size) {
 199         ctx->hwctx = av_mallocz(hw_type->device_hwctx_size);
 200         if (!ctx->hwctx)
 201             goto fail;
 202     }
 203
 204     buf = av_buffer_create((uint8_t*)ctx, sizeof(*ctx),
 205                            hwdevice_ctx_free, NULL,
 206                            AV_BUFFER_FLAG_READONLY);
 207     if (!buf)
 208         goto fail;
 209
 210     ctx->type     = type;
 211     ctx->av_class = &hwdevice_ctx_class;
 212
 213     ctxi->hw_type = hw_type;
 214
 215     return buf;
 216
 217 fail:
 218     av_freep(&ctx->hwctx);
 219     av_freep(&ctx);
 220     return NULL;
 221 }
 222
 223 int av_hwdevice_ctx_init(AVBufferRef *ref)
 224 {
 225     FFHWDeviceContext *ctxi = (FFHWDeviceContext*)ref->data;
 226     AVHWDeviceContext *ctx  = &ctxi->p;
 227     int ret = 0;
 228
 229     if (ctxi->hw_type->device_init)
 230         ret = ctxi->hw_type->device_init(ctx);
 231
 232     return ret;
 233 }
 234
 235 static const AVClass hwframe_ctx_class = {
 236     .class_name = "AVHWFramesContext",
 237     .item_name  = av_default_item_name,
 238     .version    = LIBAVUTIL_VERSION_INT,
 239 };
 240
 241 static void hwframe_ctx_free(void *opaque, uint8_t *data)
 242 {
 243     FFHWFramesContext *ctxi = (FFHWFramesContext*)data;
 244     AVHWFramesContext *ctx  = &ctxi->p;
 245
 246     if (ctxi->pool_internal)
 247         av_buffer_pool_uninit(&ctxi->pool_internal);
 248
 249     if (ctxi->hw_type->frames_uninit)
 250         ctxi->hw_type->frames_uninit(ctx);
 251
 252     if (ctx->free)
 253         ctx->free(ctx);
 254
 255     av_buffer_unref(&ctxi->source_frames);
 256
 257     av_buffer_unref(&ctx->device_ref);
 258
 259     av_freep(&ctx->hwctx);
 260     av_freep(&ctx);
 261 }
 262
 263 AVBufferRef *av_hwframe_ctx_alloc(AVBufferRef *device_ref_in)
 264 {
 265     FFHWDeviceContext *device_ctx = (FFHWDeviceContext*)device_ref_in->data;
 266     const HWContextType  *hw_type = device_ctx->hw_type;
 267     FFHWFramesContext *ctxi;
 268     AVHWFramesContext *ctx;
 269     AVBufferRef *buf, *device_ref = NULL;
 270
 271     ctxi = av_mallocz(sizeof(*ctxi));
 272     if (!ctxi)
 273         return NULL;
 274     ctx  = &ctxi->p;
 275
 276     if (hw_type->frames_hwctx_size) {
 277         ctx->hwctx = av_mallocz(hw_type->frames_hwctx_size);
 278         if (!ctx->hwctx)
 279             goto fail;
 280     }
 281
 282     device_ref = av_buffer_ref(device_ref_in);
 283     if (!device_ref)
 284         goto fail;
 285
 286     buf = av_buffer_create((uint8_t*)ctx, sizeof(*ctx),
 287                            hwframe_ctx_free, NULL,
 288                            AV_BUFFER_FLAG_READONLY);
 289     if (!buf)
 290         goto fail;
 291
 292     ctx->av_class   = &hwframe_ctx_class;
 293     ctx->device_ref = device_ref;
 294     ctx->device_ctx = &device_ctx->p;
 295     ctx->format     = AV_PIX_FMT_NONE;
 296     ctx->sw_format  = AV_PIX_FMT_NONE;
 297
 298     ctxi->hw_type = hw_type;
 299
 300     return buf;
 301
 302 fail:
 303     av_buffer_unref(&device_ref);
 304     av_freep(&ctx->hwctx);
 305     av_freep(&ctx);
 306     return NULL;
 307 }
 308
 309 static int hwframe_pool_prealloc(AVBufferRef *ref)
 310 {
 311     AVHWFramesContext *ctx = (AVHWFramesContext*)ref->data;
 312     AVFrame **frames;
 313     int i, ret = 0;
 314
 315     frames = av_calloc(ctx->initial_pool_size, sizeof(*frames));
 316     if (!frames)
 317         return AVERROR(ENOMEM);
 318
 319     for (i = 0; i < ctx->initial_pool_size; i++) {
 320         frames[i] = av_frame_alloc();
 321         if (!frames[i])
 322             goto fail;
 323
 324         ret = av_hwframe_get_buffer(ref, frames[i], 0);
 325         if (ret < 0)
 326             goto fail;
 327     }
 328
 329 fail:
 330     for (i = 0; i < ctx->initial_pool_size; i++)
 331         av_frame_free(&frames[i]);
 332     av_freep(&frames);
 333
 334     return ret;
 335 }
 336
 337 int av_hwframe_ctx_init(AVBufferRef *ref)
 338 {
 339     FFHWFramesContext *ctxi = (FFHWFramesContext*)ref->data;
 340     AVHWFramesContext *ctx  = &ctxi->p;
 341     const enum AVPixelFormat *pix_fmt;
 342     int ret;
 343
 344     if (ctxi->source_frames) {
 345         /* A derived frame context is already initialised. */
 346         return 0;
 347     }
 348
 349     /* validate the pixel format */
 350     for (pix_fmt = ctxi->hw_type->pix_fmts; *pix_fmt != AV_PIX_FMT_NONE; pix_fmt++) {
 351         if (*pix_fmt == ctx->format)
 352             break;
 353     }
 354     if (*pix_fmt == AV_PIX_FMT_NONE) {
 355         av_log(ctx, AV_LOG_ERROR,
 356                "The hardware pixel format '%s' is not supported by the device type '%s'\n",
 357                av_get_pix_fmt_name(ctx->format), ctxi->hw_type->name);
 358         return AVERROR(ENOSYS);
 359     }
 360
 361     /* validate the dimensions */
 362     ret = av_image_check_size(ctx->width, ctx->height, 0, ctx);
 363     if (ret < 0)
 364         return ret;
 365
 366     /* format-specific init */
 367     if (ctxi->hw_type->frames_init) {
 368         ret = ctxi->hw_type->frames_init(ctx);
 369         if (ret < 0)
 370             return ret;
 371     }
 372
 373     if (ctxi->pool_internal && !ctx->pool)
 374         ctx->pool = ctxi->pool_internal;
 375
 376     /* preallocate the frames in the pool, if requested */
 377     if (ctx->initial_pool_size > 0) {
 378         ret = hwframe_pool_prealloc(ref);
 379         if (ret < 0)
 380             return ret;
 381     }
 382
 383     return 0;
 384 }
 385
 386 int av_hwframe_transfer_get_formats(AVBufferRef *hwframe_ref,
 387                                     enum AVHWFrameTransferDirection dir,
 388                                     enum AVPixelFormat **formats, int flags)
 389 {
 390     FFHWFramesContext *ctxi = (FFHWFramesContext*)hwframe_ref->data;
 391
 392     if (!ctxi->hw_type->transfer_get_formats)
 393         return AVERROR(ENOSYS);
 394
 395     return ctxi->hw_type->transfer_get_formats(&ctxi->p, dir, formats);
 396 }
 397
 398 static int transfer_data_alloc(AVFrame *dst, const AVFrame *src, int flags)
 399 {
 400     AVHWFramesContext *ctx;
 401     AVFrame *frame_tmp;
 402     int ret = 0;
 403
 404     if (!src->hw_frames_ctx)
 405         return AVERROR(EINVAL);
 406     ctx = (AVHWFramesContext*)src->hw_frames_ctx->data;
 407
 408     frame_tmp = av_frame_alloc();
 409     if (!frame_tmp)
 410         return AVERROR(ENOMEM);
 411
 412     /* if the format is set, use that
 413      * otherwise pick the first supported one */
 414     if (dst->format >= 0) {
 415         frame_tmp->format = dst->format;
 416     } else {
 417         enum AVPixelFormat *formats;
 418
 419         ret = av_hwframe_transfer_get_formats(src->hw_frames_ctx,
 420                                               AV_HWFRAME_TRANSFER_DIRECTION_FROM,
 421                                               &formats, 0);
 422         if (ret < 0)
 423             goto fail;
 424         frame_tmp->format = formats[0];
 425         av_freep(&formats);
 426     }
 427     frame_tmp->width  = ctx->width;
 428     frame_tmp->height = ctx->height;
 429
 430     ret = av_frame_get_buffer(frame_tmp, 0);
 431     if (ret < 0)
 432         goto fail;
 433
 434     ret = av_hwframe_transfer_data(frame_tmp, src, flags);
 435     if (ret < 0)
 436         goto fail;
 437
 438     frame_tmp->width  = src->width;
 439     frame_tmp->height = src->height;
 440
 441     av_frame_move_ref(dst, frame_tmp);
 442
 443 fail:
 444     av_frame_free(&frame_tmp);
 445     return ret;
 446 }
 447
 448 int av_hwframe_transfer_data(AVFrame *dst, const AVFrame *src, int flags)
 449 {
 450     int ret;
 451
 452     if (!dst->buf[0])
 453         return transfer_data_alloc(dst, src, flags);
 454
 455     /*
 456      * Hardware -> Hardware Transfer.
 457      * Unlike Software -> Hardware or Hardware -> Software, the transfer
 458      * function could be provided by either the src or dst, depending on
 459      * the specific combination of hardware.
 460      */
 461     if (src->hw_frames_ctx && dst->hw_frames_ctx) {
 462         FFHWFramesContext *src_ctx =
 463             (FFHWFramesContext*)src->hw_frames_ctx->data;
 464         FFHWFramesContext *dst_ctx =
 465             (FFHWFramesContext*)dst->hw_frames_ctx->data;
 466
 467         if (src_ctx->source_frames) {
 468             av_log(src_ctx, AV_LOG_ERROR,
 469                    "A device with a derived frame context cannot be used as "
 470                    "the source of a HW -> HW transfer.");
 471             return AVERROR(ENOSYS);
 472         }
 473
 474         if (dst_ctx->source_frames) {
 475             av_log(src_ctx, AV_LOG_ERROR,
 476                    "A device with a derived frame context cannot be used as "
 477                    "the destination of a HW -> HW transfer.");
 478             return AVERROR(ENOSYS);
 479         }
 480
 481         ret = src_ctx->hw_type->transfer_data_from(&src_ctx->p, dst, src);
 482         if (ret == AVERROR(ENOSYS))
 483             ret = dst_ctx->hw_type->transfer_data_to(&dst_ctx->p, dst, src);
 484         if (ret < 0)
 485             return ret;
 486     } else {
 487         if (src->hw_frames_ctx) {
 488             FFHWFramesContext *ctx = (FFHWFramesContext*)src->hw_frames_ctx->data;
 489
 490             ret = ctx->hw_type->transfer_data_from(&ctx->p, dst, src);
 491             if (ret < 0)
 492                 return ret;
 493         } else if (dst->hw_frames_ctx) {
 494             FFHWFramesContext *ctx = (FFHWFramesContext*)dst->hw_frames_ctx->data;
 495
 496             ret = ctx->hw_type->transfer_data_to(&ctx->p, dst, src);
 497             if (ret < 0)
 498                 return ret;
 499         } else {
 500             return AVERROR(ENOSYS);
 501         }
 502     }
 503     return 0;
 504 }
 505
 506 int av_hwframe_get_buffer(AVBufferRef *hwframe_ref, AVFrame *frame, int flags)
 507 {
 508     FFHWFramesContext *ctxi = (FFHWFramesContext*)hwframe_ref->data;
 509     AVHWFramesContext *ctx  = &ctxi->p;
 510     int ret;
 511
 512     if (ctxi->source_frames) {
 513         // This is a derived frame context, so we allocate in the source
 514         // and map the frame immediately.
 515         AVFrame *src_frame;
 516
 517         frame->format = ctx->format;
 518         frame->hw_frames_ctx = av_buffer_ref(hwframe_ref);
 519         if (!frame->hw_frames_ctx)
 520             return AVERROR(ENOMEM);
 521
 522         src_frame = av_frame_alloc();
 523         if (!src_frame)
 524             return AVERROR(ENOMEM);
 525
 526         ret = av_hwframe_get_buffer(ctxi->source_frames,
 527                                     src_frame, 0);
 528         if (ret < 0) {
 529             av_frame_free(&src_frame);
 530             return ret;
 531         }
 532
 533         ret = av_hwframe_map(frame, src_frame,
 534                              ctxi->source_allocation_map_flags);
 535         if (ret) {
 536             av_log(ctx, AV_LOG_ERROR, "Failed to map frame into derived "
 537                    "frame context: %d.\n", ret);
 538             av_frame_free(&src_frame);
 539             return ret;
 540         }
 541
 542         // Free the source frame immediately - the mapped frame still
 543         // contains a reference to it.
 544         av_frame_free(&src_frame);
 545
 546         return 0;
 547     }
 548
 549     if (!ctxi->hw_type->frames_get_buffer)
 550         return AVERROR(ENOSYS);
 551
 552     if (!ctx->pool)
 553         return AVERROR(EINVAL);
 554
 555     frame->hw_frames_ctx = av_buffer_ref(hwframe_ref);
 556     if (!frame->hw_frames_ctx)
 557         return AVERROR(ENOMEM);
 558
 559     ret = ctxi->hw_type->frames_get_buffer(ctx, frame);
 560     if (ret < 0) {
 561         av_buffer_unref(&frame->hw_frames_ctx);
 562         return ret;
 563     }
 564
 565     frame->extended_data = frame->data;
 566
 567     return 0;
 568 }
 569
 570 void *av_hwdevice_hwconfig_alloc(AVBufferRef *ref)
 571 {
 572     FFHWDeviceContext *ctx = (FFHWDeviceContext*)ref->data;
 573     const HWContextType  *hw_type = ctx->hw_type;
 574
 575     if (hw_type->device_hwconfig_size == 0)
 576         return NULL;
 577
 578     return av_mallocz(hw_type->device_hwconfig_size);
 579 }
 580
 581 AVHWFramesConstraints *av_hwdevice_get_hwframe_constraints(AVBufferRef *ref,
 582                                                            const void *hwconfig)
 583 {
 584     FFHWDeviceContext *ctx = (FFHWDeviceContext*)ref->data;
 585     const HWContextType  *hw_type = ctx->hw_type;
 586     AVHWFramesConstraints *constraints;
 587
 588     if (!hw_type->frames_get_constraints)
 589         return NULL;
 590
 591     constraints = av_mallocz(sizeof(*constraints));
 592     if (!constraints)
 593         return NULL;
 594
 595     constraints->min_width = constraints->min_height = 0;
 596     constraints->max_width = constraints->max_height = INT_MAX;
 597
 598     if (hw_type->frames_get_constraints(&ctx->p, hwconfig, constraints) >= 0) {
 599         return constraints;
 600     } else {
 601         av_hwframe_constraints_free(&constraints);
 602         return NULL;
 603     }
 604 }
 605
 606 void av_hwframe_constraints_free(AVHWFramesConstraints **constraints)
 607 {
 608     if (*constraints) {
 609         av_freep(&(*constraints)->valid_hw_formats);
 610         av_freep(&(*constraints)->valid_sw_formats);
 611     }
 612     av_freep(constraints);
 613 }
 614
 615 int av_hwdevice_ctx_create(AVBufferRef **pdevice_ref, enum AVHWDeviceType type,
 616                            const char *device, AVDictionary *opts, int flags)
 617 {
 618     AVBufferRef *device_ref = NULL;
 619     FFHWDeviceContext *device_ctx;
 620     int ret = 0;
 621
 622     device_ref = av_hwdevice_ctx_alloc(type);
 623     if (!device_ref) {
 624         ret = AVERROR(ENOMEM);
 625         goto fail;
 626     }
 627     device_ctx = (FFHWDeviceContext*)device_ref->data;
 628
 629     if (!device_ctx->hw_type->device_create) {
 630         ret = AVERROR(ENOSYS);
 631         goto fail;
 632     }
 633
 634     ret = device_ctx->hw_type->device_create(&device_ctx->p, device,
 635                                              opts, flags);
 636     if (ret < 0)
 637         goto fail;
 638
 639     ret = av_hwdevice_ctx_init(device_ref);
 640     if (ret < 0)
 641         goto fail;
 642
 643     *pdevice_ref = device_ref;
 644     return 0;
 645 fail:
 646     av_buffer_unref(&device_ref);
 647     *pdevice_ref = NULL;
 648     return ret;
 649 }
 650
 651 int av_hwdevice_ctx_create_derived_opts(AVBufferRef **dst_ref_ptr,
 652                                         enum AVHWDeviceType type,
 653                                         AVBufferRef *src_ref,
 654                                         AVDictionary *options, int flags)
 655 {
 656     AVBufferRef *dst_ref = NULL, *tmp_ref;
 657     FFHWDeviceContext *dst_ctx;
 658     int ret = 0;
 659
 660     tmp_ref = src_ref;
 661     while (tmp_ref) {
 662         FFHWDeviceContext *tmp_ctx = (FFHWDeviceContext*)tmp_ref->data;
 663         if (tmp_ctx->p.type == type) {
 664             dst_ref = av_buffer_ref(tmp_ref);
 665             if (!dst_ref) {
 666                 ret = AVERROR(ENOMEM);
 667                 goto fail;
 668             }
 669             goto done;
 670         }
 671         tmp_ref = tmp_ctx->source_device;
 672     }
 673
 674     dst_ref = av_hwdevice_ctx_alloc(type);
 675     if (!dst_ref) {
 676         ret = AVERROR(ENOMEM);
 677         goto fail;
 678     }
 679     dst_ctx = (FFHWDeviceContext*)dst_ref->data;
 680
 681     tmp_ref = src_ref;
 682     while (tmp_ref) {
 683         FFHWDeviceContext *tmp_ctx = (FFHWDeviceContext*)tmp_ref->data;
 684         if (dst_ctx->hw_type->device_derive) {
 685             ret = dst_ctx->hw_type->device_derive(&dst_ctx->p,
 686                                                   &tmp_ctx->p,
 687                                                   options, flags);
 688             if (ret == 0) {
 689                 dst_ctx->source_device = av_buffer_ref(src_ref);
 690                 if (!dst_ctx->source_device) {
 691                     ret = AVERROR(ENOMEM);
 692                     goto fail;
 693                 }
 694                 ret = av_hwdevice_ctx_init(dst_ref);
 695                 if (ret < 0)
 696                     goto fail;
 697                 goto done;
 698             }
 699             if (ret != AVERROR(ENOSYS))
 700                 goto fail;
 701         }
 702         tmp_ref = tmp_ctx->source_device;
 703     }
 704
 705     ret = AVERROR(ENOSYS);
 706     goto fail;
 707
 708 done:
 709     *dst_ref_ptr = dst_ref;
 710     return 0;
 711
 712 fail:
 713     av_buffer_unref(&dst_ref);
 714     *dst_ref_ptr = NULL;
 715     return ret;
 716 }
 717
 718 int av_hwdevice_ctx_create_derived(AVBufferRef **dst_ref_ptr,
 719                                    enum AVHWDeviceType type,
 720                                    AVBufferRef *src_ref, int flags)
 721 {
 722     return av_hwdevice_ctx_create_derived_opts(dst_ref_ptr, type, src_ref,
 723                                                NULL, flags);
 724 }
 725
 726 static void ff_hwframe_unmap(void *opaque, uint8_t *data)
 727 {
 728     HWMapDescriptor *hwmap = (HWMapDescriptor*)data;
 729     AVHWFramesContext *ctx = opaque;
 730
 731     if (hwmap->unmap)
 732         hwmap->unmap(ctx, hwmap);
 733
 734     av_frame_free(&hwmap->source);
 735
 736     av_buffer_unref(&hwmap->hw_frames_ctx);
 737
 738     av_free(hwmap);
 739 }
 740
 741 int ff_hwframe_map_create(AVBufferRef *hwframe_ref,
 742                           AVFrame *dst, const AVFrame *src,
 743                           void (*unmap)(AVHWFramesContext *ctx,
 744                                         HWMapDescriptor *hwmap),
 745                           void *priv)
 746 {
 747     AVHWFramesContext *ctx = (AVHWFramesContext*)hwframe_ref->data;
 748     HWMapDescriptor *hwmap;
 749     int ret;
 750
 751     hwmap = av_mallocz(sizeof(*hwmap));
 752     if (!hwmap) {
 753         ret = AVERROR(ENOMEM);
 754         goto fail;
 755     }
 756
 757     hwmap->source = av_frame_alloc();
 758     if (!hwmap->source) {
 759         ret = AVERROR(ENOMEM);
 760         goto fail;
 761     }
 762     ret = av_frame_ref(hwmap->source, src);
 763     if (ret < 0)
 764         goto fail;
 765
 766     hwmap->hw_frames_ctx = av_buffer_ref(hwframe_ref);
 767     if (!hwmap->hw_frames_ctx) {
 768         ret = AVERROR(ENOMEM);
 769         goto fail;
 770     }
 771
 772     hwmap->unmap = unmap;
 773     hwmap->priv  = priv;
 774
 775     dst->buf[0] = av_buffer_create((uint8_t*)hwmap, sizeof(*hwmap),
 776                                    &ff_hwframe_unmap, ctx, 0);
 777     if (!dst->buf[0]) {
 778         ret = AVERROR(ENOMEM);
 779         goto fail;
 780     }
 781
 782     return 0;
 783
 784 fail:
 785     if (hwmap) {
 786         av_buffer_unref(&hwmap->hw_frames_ctx);
 787         av_frame_free(&hwmap->source);
 788     }
 789     av_free(hwmap);
 790     return ret;
 791 }
 792
 793 int av_hwframe_map(AVFrame *dst, const AVFrame *src, int flags)
 794 {
 795     AVBufferRef    *orig_dst_frames = dst->hw_frames_ctx;
 796     enum AVPixelFormat orig_dst_fmt = dst->format;
 797     HWMapDescriptor *hwmap;
 798     int ret;
 799
 800     if (src->hw_frames_ctx && dst->hw_frames_ctx) {
 801         FFHWFramesContext *src_frames = (FFHWFramesContext*)src->hw_frames_ctx->data;
 802         FFHWFramesContext *dst_frames = (FFHWFramesContext*)dst->hw_frames_ctx->data;
 803
 804         if ((src_frames == dst_frames &&
 805              src->format == dst_frames->p.sw_format &&
 806              dst->format == dst_frames->p.format) ||
 807             (src_frames->source_frames &&
 808              src_frames->source_frames->data ==
 809              (uint8_t*)dst_frames)) {
 810             // This is an unmap operation.  We don't need to directly
 811             // do anything here other than fill in the original frame,
 812             // because the real unmap will be invoked when the last
 813             // reference to the mapped frame disappears.
 814             if (!src->buf[0]) {
 815                 av_log(src_frames, AV_LOG_ERROR, "Invalid mapping "
 816                        "found when attempting unmap.\n");
 817                 return AVERROR(EINVAL);
 818             }
 819             hwmap = (HWMapDescriptor*)src->buf[0]->data;
 820             return av_frame_replace(dst, hwmap->source);
 821         }
 822     }
 823
 824     if (src->hw_frames_ctx) {
 825         FFHWFramesContext *src_frames = (FFHWFramesContext*)src->hw_frames_ctx->data;
 826
 827         if (src_frames->p.format == src->format &&
 828             src_frames->hw_type->map_from) {
 829             ret = src_frames->hw_type->map_from(&src_frames->p,
 830                                                 dst, src, flags);
 831             if (ret >= 0)
 832                 return ret;
 833             else if (ret != AVERROR(ENOSYS))
 834                 goto fail;
 835         }
 836     }
 837
 838     if (dst->hw_frames_ctx) {
 839         FFHWFramesContext *dst_frames = (FFHWFramesContext*)dst->hw_frames_ctx->data;
 840
 841         if (dst_frames->p.format == dst->format &&
 842             dst_frames->hw_type->map_to) {
 843             ret = dst_frames->hw_type->map_to(&dst_frames->p,
 844                                               dst, src, flags);
 845             if (ret >= 0)
 846                 return ret;
 847             else if (ret != AVERROR(ENOSYS))
 848                 goto fail;
 849         }
 850     }
 851
 852     return AVERROR(ENOSYS);
 853
 854 fail:
 855     // if the caller provided dst frames context, it should be preserved
 856     // by this function
 857     av_assert0(orig_dst_frames == NULL ||
 858                orig_dst_frames == dst->hw_frames_ctx);
 859
 860     // preserve user-provided dst frame fields, but clean
 861     // anything we might have set
 862     dst->hw_frames_ctx = NULL;
 863     av_frame_unref(dst);
 864
 865     dst->hw_frames_ctx = orig_dst_frames;
 866     dst->format        = orig_dst_fmt;
 867
 868     return ret;
 869 }
 870
 871 int av_hwframe_ctx_create_derived(AVBufferRef **derived_frame_ctx,
 872                                   enum AVPixelFormat format,
 873                                   AVBufferRef *derived_device_ctx,
 874                                   AVBufferRef *source_frame_ctx,
 875                                   int flags)
 876 {
 877     AVBufferRef   *dst_ref = NULL;
 878     FFHWFramesContext *dsti = NULL;
 879     FFHWFramesContext *srci = (FFHWFramesContext*)source_frame_ctx->data;
 880     AVHWFramesContext *dst, *src = &srci->p;
 881     int ret;
 882
 883     if (srci->source_frames) {
 884         AVHWFramesContext *src_src =
 885             (AVHWFramesContext*)srci->source_frames->data;
 886         AVHWDeviceContext *dst_dev =
 887             (AVHWDeviceContext*)derived_device_ctx->data;
 888
 889         if (src_src->device_ctx == dst_dev) {
 890             // This is actually an unmapping, so we just return a
 891             // reference to the source frame context.
 892             *derived_frame_ctx = av_buffer_ref(srci->source_frames);
 893             if (!*derived_frame_ctx) {
 894                 ret = AVERROR(ENOMEM);
 895                 goto fail;
 896             }
 897             return 0;
 898         }
 899     }
 900
 901     dst_ref = av_hwframe_ctx_alloc(derived_device_ctx);
 902     if (!dst_ref) {
 903         ret = AVERROR(ENOMEM);
 904         goto fail;
 905     }
 906
 907     dsti = (FFHWFramesContext*)dst_ref->data;
 908     dst  = &dsti->p;
 909
 910     dst->format    = format;
 911     dst->sw_format = src->sw_format;
 912     dst->width     = src->width;
 913     dst->height    = src->height;
 914
 915     dsti->source_frames = av_buffer_ref(source_frame_ctx);
 916     if (!dsti->source_frames) {
 917         ret = AVERROR(ENOMEM);
 918         goto fail;
 919     }
 920
 921     dsti->source_allocation_map_flags =
 922         flags & (AV_HWFRAME_MAP_READ      |
 923                  AV_HWFRAME_MAP_WRITE     |
 924                  AV_HWFRAME_MAP_OVERWRITE |
 925                  AV_HWFRAME_MAP_DIRECT);
 926
 927     ret = AVERROR(ENOSYS);
 928     if (srci->hw_type->frames_derive_from)
 929         ret = srci->hw_type->frames_derive_from(dst, src, flags);
 930     if (ret == AVERROR(ENOSYS) &&
 931         dsti->hw_type->frames_derive_to)
 932         ret = dsti->hw_type->frames_derive_to(dst, src, flags);
 933     if (ret == AVERROR(ENOSYS))
 934         ret = 0;
 935     if (ret)
 936         goto fail;
 937
 938     *derived_frame_ctx = dst_ref;
 939     return 0;
 940
 941 fail:
 942     if (dsti)
 943         av_buffer_unref(&dsti->source_frames);
 944     av_buffer_unref(&dst_ref);
 945     return ret;
 946 }
 947
 948 int ff_hwframe_map_replace(AVFrame *dst, const AVFrame *src)
 949 {
 950     HWMapDescriptor *hwmap = (HWMapDescriptor*)dst->buf[0]->data;
 951     return av_frame_replace(hwmap->source, src);
 952 }