git.sesse.net Git - ffmpeg/blob - libavfilter/vf_hwmap.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 "libavutil/buffer.h"
  20 #include "libavutil/hwcontext.h"
  21 #include "libavutil/log.h"
  22 #include "libavutil/opt.h"
  23 #include "libavutil/pixdesc.h"
  24
  25 #include "avfilter.h"
  26 #include "formats.h"
  27 #include "internal.h"
  28 #include "video.h"
  29
  30 typedef struct HWMapContext {
  31     const AVClass *class;
  32
  33     AVBufferRef   *hwframes_ref;
  34
  35     int            mode;
  36     char          *derive_device_type;
  37     int            reverse;
  38 } HWMapContext;
  39
  40 static int hwmap_query_formats(AVFilterContext *avctx)
  41 {
  42     int ret;
  43
  44     if ((ret = ff_formats_ref(ff_all_formats(AVMEDIA_TYPE_VIDEO),
  45                               &avctx->inputs[0]->outcfg.formats)) < 0 ||
  46         (ret = ff_formats_ref(ff_all_formats(AVMEDIA_TYPE_VIDEO),
  47                               &avctx->outputs[0]->incfg.formats)) < 0)
  48         return ret;
  49
  50     return 0;
  51 }
  52
  53 static int hwmap_config_output(AVFilterLink *outlink)
  54 {
  55     AVFilterContext *avctx = outlink->src;
  56     HWMapContext      *ctx = avctx->priv;
  57     AVFilterLink   *inlink = avctx->inputs[0];
  58     AVHWFramesContext *hwfc;
  59     AVBufferRef *device;
  60     const AVPixFmtDescriptor *desc;
  61     int err, device_is_derived;
  62
  63     av_log(avctx, AV_LOG_DEBUG, "Configure hwmap %s -> %s.\n",
  64            av_get_pix_fmt_name(inlink->format),
  65            av_get_pix_fmt_name(outlink->format));
  66
  67     av_buffer_unref(&ctx->hwframes_ref);
  68
  69     device = avctx->hw_device_ctx;
  70     device_is_derived = 0;
  71
  72     if (inlink->hw_frames_ctx) {
  73         hwfc = (AVHWFramesContext*)inlink->hw_frames_ctx->data;
  74
  75         if (ctx->derive_device_type) {
  76             enum AVHWDeviceType type;
  77
  78             type = av_hwdevice_find_type_by_name(ctx->derive_device_type);
  79             if (type == AV_HWDEVICE_TYPE_NONE) {
  80                 av_log(avctx, AV_LOG_ERROR, "Invalid device type.\n");
  81                 err = AVERROR(EINVAL);
  82                 goto fail;
  83             }
  84
  85             err = av_hwdevice_ctx_create_derived(&device, type,
  86                                                  hwfc->device_ref, 0);
  87             if (err < 0) {
  88                 av_log(avctx, AV_LOG_ERROR, "Failed to created derived "
  89                        "device context: %d.\n", err);
  90                 goto fail;
  91             }
  92             device_is_derived = 1;
  93         }
  94
  95         desc = av_pix_fmt_desc_get(outlink->format);
  96         if (!desc) {
  97             err = AVERROR(EINVAL);
  98             goto fail;
  99         }
 100
 101         if (inlink->format == hwfc->format &&
 102             (desc->flags & AV_PIX_FMT_FLAG_HWACCEL) &&
 103             !ctx->reverse) {
 104             // Map between two hardware formats (including the case of
 105             // undoing an existing mapping).
 106
 107             if (!device) {
 108                 av_log(avctx, AV_LOG_ERROR, "A device reference is "
 109                        "required to map to a hardware format.\n");
 110                 err = AVERROR(EINVAL);
 111                 goto fail;
 112             }
 113
 114             err = av_hwframe_ctx_create_derived(&ctx->hwframes_ref,
 115                                                 outlink->format,
 116                                                 device,
 117                                                 inlink->hw_frames_ctx,
 118                                                 ctx->mode);
 119             if (err < 0) {
 120                 av_log(avctx, AV_LOG_ERROR, "Failed to create derived "
 121                        "frames context: %d.\n", err);
 122                 goto fail;
 123             }
 124
 125         } else if (inlink->format == hwfc->format &&
 126                    (desc->flags & AV_PIX_FMT_FLAG_HWACCEL) &&
 127                    ctx->reverse) {
 128             // Map between two hardware formats, but do it in reverse.
 129             // Make a new hwframe context for the target type, and then
 130             // overwrite the input hwframe context with a derived context
 131             // mapped from that back to the source type.
 132             AVBufferRef *source;
 133             AVHWFramesContext *frames;
 134
 135             ctx->hwframes_ref = av_hwframe_ctx_alloc(device);
 136             if (!ctx->hwframes_ref) {
 137                 err = AVERROR(ENOMEM);
 138                 goto fail;
 139             }
 140             frames = (AVHWFramesContext*)ctx->hwframes_ref->data;
 141
 142             frames->format    = outlink->format;
 143             frames->sw_format = hwfc->sw_format;
 144             frames->width     = hwfc->width;
 145             frames->height    = hwfc->height;
 146
 147             if (avctx->extra_hw_frames >= 0)
 148                 frames->initial_pool_size = 2 + avctx->extra_hw_frames;
 149
 150             err = av_hwframe_ctx_init(ctx->hwframes_ref);
 151             if (err < 0) {
 152                 av_log(avctx, AV_LOG_ERROR, "Failed to initialise "
 153                        "target frames context: %d.\n", err);
 154                 goto fail;
 155             }
 156
 157             err = av_hwframe_ctx_create_derived(&source,
 158                                                 inlink->format,
 159                                                 hwfc->device_ref,
 160                                                 ctx->hwframes_ref,
 161                                                 ctx->mode);
 162             if (err < 0) {
 163                 av_log(avctx, AV_LOG_ERROR, "Failed to create "
 164                        "derived source frames context: %d.\n", err);
 165                 goto fail;
 166             }
 167
 168             // Here is the naughty bit.  This overwriting changes what
 169             // ff_get_video_buffer() in the previous filter returns -
 170             // it will now give a frame allocated here mapped back to
 171             // the format it expects.  If there were any additional
 172             // constraints on the output frames there then this may
 173             // break nastily.
 174             av_buffer_unref(&inlink->hw_frames_ctx);
 175             inlink->hw_frames_ctx = source;
 176
 177         } else if ((outlink->format == hwfc->format &&
 178                     inlink->format  == hwfc->sw_format) ||
 179                    inlink->format == hwfc->format) {
 180             // Map from a hardware format to a software format, or
 181             // undo an existing such mapping.
 182
 183             ctx->hwframes_ref = av_buffer_ref(inlink->hw_frames_ctx);
 184             if (!ctx->hwframes_ref) {
 185                 err = AVERROR(ENOMEM);
 186                 goto fail;
 187             }
 188
 189         } else {
 190             // Non-matching formats - not supported.
 191
 192             av_log(avctx, AV_LOG_ERROR, "Unsupported formats for "
 193                    "hwmap: from %s (%s) to %s.\n",
 194                    av_get_pix_fmt_name(inlink->format),
 195                    av_get_pix_fmt_name(hwfc->format),
 196                    av_get_pix_fmt_name(outlink->format));
 197             err = AVERROR(EINVAL);
 198             goto fail;
 199         }
 200     } else if (avctx->hw_device_ctx) {
 201         // Map from a software format to a hardware format.  This
 202         // creates a new hwframe context like hwupload, but then
 203         // returns frames mapped from that to the previous link in
 204         // order to fill them without an additional copy.
 205
 206         if (!device) {
 207             av_log(avctx, AV_LOG_ERROR, "A device reference is "
 208                    "required to create new frames with reverse "
 209                    "mapping.\n");
 210             err = AVERROR(EINVAL);
 211             goto fail;
 212         }
 213
 214         ctx->reverse = 1;
 215
 216         ctx->hwframes_ref = av_hwframe_ctx_alloc(device);
 217         if (!ctx->hwframes_ref) {
 218             err = AVERROR(ENOMEM);
 219             goto fail;
 220         }
 221         hwfc = (AVHWFramesContext*)ctx->hwframes_ref->data;
 222
 223         hwfc->format    = outlink->format;
 224         hwfc->sw_format = inlink->format;
 225         hwfc->width     = inlink->w;
 226         hwfc->height    = inlink->h;
 227
 228         if (avctx->extra_hw_frames >= 0)
 229             hwfc->initial_pool_size = 2 + avctx->extra_hw_frames;
 230
 231         err = av_hwframe_ctx_init(ctx->hwframes_ref);
 232         if (err < 0) {
 233             av_log(avctx, AV_LOG_ERROR, "Failed to create frame "
 234                    "context for reverse mapping: %d.\n", err);
 235             goto fail;
 236         }
 237
 238     } else {
 239         av_log(avctx, AV_LOG_ERROR, "Mapping requires a hardware "
 240                "context (a device, or frames on input).\n");
 241         return AVERROR(EINVAL);
 242     }
 243
 244     outlink->hw_frames_ctx = av_buffer_ref(ctx->hwframes_ref);
 245     if (!outlink->hw_frames_ctx) {
 246         err = AVERROR(ENOMEM);
 247         goto fail;
 248     }
 249
 250     outlink->w = inlink->w;
 251     outlink->h = inlink->h;
 252
 253     if (device_is_derived)
 254         av_buffer_unref(&device);
 255     return 0;
 256
 257 fail:
 258     if (device_is_derived)
 259         av_buffer_unref(&device);
 260     av_buffer_unref(&ctx->hwframes_ref);
 261     return err;
 262 }
 263
 264 static AVFrame *hwmap_get_buffer(AVFilterLink *inlink, int w, int h)
 265 {
 266     AVFilterContext *avctx = inlink->dst;
 267     AVFilterLink  *outlink = avctx->outputs[0];
 268     HWMapContext      *ctx = avctx->priv;
 269
 270     if (ctx->reverse && !inlink->hw_frames_ctx) {
 271         AVFrame *src, *dst;
 272         int err;
 273
 274         src = ff_get_video_buffer(outlink, w, h);
 275         if (!src) {
 276             av_log(avctx, AV_LOG_ERROR, "Failed to allocate source "
 277                    "frame for software mapping.\n");
 278             return NULL;
 279         }
 280
 281         dst = av_frame_alloc();
 282         if (!dst) {
 283             av_frame_free(&src);
 284             return NULL;
 285         }
 286
 287         err = av_hwframe_map(dst, src, ctx->mode);
 288         if (err) {
 289             av_log(avctx, AV_LOG_ERROR, "Failed to map frame to "
 290                    "software: %d.\n", err);
 291             av_frame_free(&src);
 292             av_frame_free(&dst);
 293             return NULL;
 294         }
 295
 296         av_frame_free(&src);
 297         return dst;
 298     } else {
 299         return ff_default_get_video_buffer(inlink, w, h);
 300     }
 301 }
 302
 303 static int hwmap_filter_frame(AVFilterLink *link, AVFrame *input)
 304 {
 305     AVFilterContext *avctx = link->dst;
 306     AVFilterLink  *outlink = avctx->outputs[0];
 307     HWMapContext      *ctx = avctx->priv;
 308     AVFrame *map = NULL;
 309     int err;
 310
 311     av_log(ctx, AV_LOG_DEBUG, "Filter input: %s, %ux%u (%"PRId64").\n",
 312            av_get_pix_fmt_name(input->format),
 313            input->width, input->height, input->pts);
 314
 315     map = av_frame_alloc();
 316     if (!map) {
 317         err = AVERROR(ENOMEM);
 318         goto fail;
 319     }
 320
 321     map->format = outlink->format;
 322     map->hw_frames_ctx = av_buffer_ref(ctx->hwframes_ref);
 323     if (!map->hw_frames_ctx) {
 324         err = AVERROR(ENOMEM);
 325         goto fail;
 326     }
 327
 328     if (ctx->reverse && !input->hw_frames_ctx) {
 329         // If we mapped backwards from hardware to software, we need
 330         // to attach the hardware frame context to the input frame to
 331         // make the mapping visible to av_hwframe_map().
 332         input->hw_frames_ctx = av_buffer_ref(ctx->hwframes_ref);
 333         if (!input->hw_frames_ctx) {
 334             err = AVERROR(ENOMEM);
 335             goto fail;
 336         }
 337     }
 338
 339     err = av_hwframe_map(map, input, ctx->mode);
 340     if (err < 0) {
 341         av_log(avctx, AV_LOG_ERROR, "Failed to map frame: %d.\n", err);
 342         goto fail;
 343     }
 344
 345     err = av_frame_copy_props(map, input);
 346     if (err < 0)
 347         goto fail;
 348
 349     av_frame_free(&input);
 350
 351     av_log(ctx, AV_LOG_DEBUG, "Filter output: %s, %ux%u (%"PRId64").\n",
 352            av_get_pix_fmt_name(map->format),
 353            map->width, map->height, map->pts);
 354
 355     return ff_filter_frame(outlink, map);
 356
 357 fail:
 358     av_frame_free(&input);
 359     av_frame_free(&map);
 360     return err;
 361 }
 362
 363 static av_cold void hwmap_uninit(AVFilterContext *avctx)
 364 {
 365     HWMapContext *ctx = avctx->priv;
 366
 367     av_buffer_unref(&ctx->hwframes_ref);
 368 }
 369
 370 #define OFFSET(x) offsetof(HWMapContext, x)
 371 #define FLAGS (AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM)
 372 static const AVOption hwmap_options[] = {
 373     { "mode", "Frame mapping mode",
 374       OFFSET(mode), AV_OPT_TYPE_FLAGS,
 375       { .i64 = AV_HWFRAME_MAP_READ | AV_HWFRAME_MAP_WRITE },
 376       0, INT_MAX, FLAGS, "mode" },
 377
 378     { "read", "Mapping should be readable",
 379       0, AV_OPT_TYPE_CONST, { .i64 = AV_HWFRAME_MAP_READ },
 380       INT_MIN, INT_MAX, FLAGS, "mode" },
 381     { "write", "Mapping should be writeable",
 382       0, AV_OPT_TYPE_CONST, { .i64 = AV_HWFRAME_MAP_WRITE },
 383       INT_MIN, INT_MAX, FLAGS, "mode" },
 384     { "overwrite", "Mapping will always overwrite the entire frame",
 385       0, AV_OPT_TYPE_CONST, { .i64 = AV_HWFRAME_MAP_OVERWRITE },
 386       INT_MIN, INT_MAX, FLAGS, "mode" },
 387     { "direct", "Mapping should not involve any copying",
 388       0, AV_OPT_TYPE_CONST, { .i64 = AV_HWFRAME_MAP_DIRECT },
 389       INT_MIN, INT_MAX, FLAGS, "mode" },
 390
 391     { "derive_device", "Derive a new device of this type",
 392       OFFSET(derive_device_type), AV_OPT_TYPE_STRING,
 393       { .str = NULL }, 0, 0, FLAGS },
 394     { "reverse", "Map in reverse (create and allocate in the sink)",
 395       OFFSET(reverse), AV_OPT_TYPE_INT,
 396       { .i64 = 0 }, 0, 1, FLAGS },
 397
 398     { NULL }
 399 };
 400
 401 AVFILTER_DEFINE_CLASS(hwmap);
 402
 403 static const AVFilterPad hwmap_inputs[] = {
 404     {
 405         .name             = "default",
 406         .type             = AVMEDIA_TYPE_VIDEO,
 407         .get_video_buffer = hwmap_get_buffer,
 408         .filter_frame     = hwmap_filter_frame,
 409     },
 410     { NULL }
 411 };
 412
 413 static const AVFilterPad hwmap_outputs[] = {
 414     {
 415         .name         = "default",
 416         .type         = AVMEDIA_TYPE_VIDEO,
 417         .config_props = hwmap_config_output,
 418     },
 419     { NULL }
 420 };
 421
 422 AVFilter ff_vf_hwmap = {
 423     .name           = "hwmap",
 424     .description    = NULL_IF_CONFIG_SMALL("Map hardware frames"),
 425     .uninit         = hwmap_uninit,
 426     .priv_size      = sizeof(HWMapContext),
 427     .priv_class     = &hwmap_class,
 428     .query_formats  = hwmap_query_formats,
 429     .inputs         = hwmap_inputs,
 430     .outputs        = hwmap_outputs,
 431     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 432 };