LCOV - code coverage report
Current view: top level - libavutil - hwcontext.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 469 0.0 %
Date: 2018-05-20 11:54:08 Functions: 0 23 0.0 %

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

Generated by: LCOV version 1.13