git.sesse.net Git - ffmpeg/blob - libavfilter/vf_hwupload_cuda.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
  24 #include "avfilter.h"
  25 #include "formats.h"
  26 #include "internal.h"
  27 #include "video.h"
  28
  29 typedef struct CudaUploadContext {
  30     const AVClass *class;
  31     int device_idx;
  32
  33     AVBufferRef *hwdevice;
  34     AVBufferRef *hwframe;
  35 } CudaUploadContext;
  36
  37 static av_cold int cudaupload_init(AVFilterContext *ctx)
  38 {
  39     CudaUploadContext *s = ctx->priv;
  40     char buf[64] = { 0 };
  41
  42     snprintf(buf, sizeof(buf), "%d", s->device_idx);
  43
  44     return av_hwdevice_ctx_create(&s->hwdevice, AV_HWDEVICE_TYPE_CUDA, buf, NULL, 0);
  45 }
  46
  47 static av_cold void cudaupload_uninit(AVFilterContext *ctx)
  48 {
  49     CudaUploadContext *s = ctx->priv;
  50
  51     av_buffer_unref(&s->hwframe);
  52     av_buffer_unref(&s->hwdevice);
  53 }
  54
  55 static int cudaupload_query_formats(AVFilterContext *ctx)
  56 {
  57     int ret;
  58
  59     static const enum AVPixelFormat input_pix_fmts[] = {
  60         AV_PIX_FMT_NV12, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV444P,
  61         AV_PIX_FMT_NONE,
  62     };
  63     static const enum AVPixelFormat output_pix_fmts[] = {
  64         AV_PIX_FMT_CUDA, AV_PIX_FMT_NONE,
  65     };
  66     AVFilterFormats *in_fmts  = ff_make_format_list(input_pix_fmts);
  67     AVFilterFormats *out_fmts;
  68
  69     ret = ff_formats_ref(in_fmts, &ctx->inputs[0]->out_formats);
  70     if (ret < 0)
  71         return ret;
  72
  73     out_fmts = ff_make_format_list(output_pix_fmts);
  74
  75     ret = ff_formats_ref(out_fmts, &ctx->outputs[0]->in_formats);
  76     if (ret < 0)
  77         return ret;
  78
  79     return 0;
  80 }
  81
  82 static int cudaupload_config_output(AVFilterLink *outlink)
  83 {
  84     AVFilterContext *ctx = outlink->src;
  85     AVFilterLink *inlink = ctx->inputs[0];
  86     CudaUploadContext *s = ctx->priv;
  87
  88     AVHWFramesContext *hwframe_ctx;
  89     int ret;
  90
  91     av_buffer_unref(&s->hwframe);
  92     s->hwframe = av_hwframe_ctx_alloc(s->hwdevice);
  93     if (!s->hwframe)
  94         return AVERROR(ENOMEM);
  95
  96     hwframe_ctx            = (AVHWFramesContext*)s->hwframe->data;
  97     hwframe_ctx->format    = AV_PIX_FMT_CUDA;
  98     hwframe_ctx->sw_format = inlink->format;
  99     hwframe_ctx->width     = inlink->w;
 100     hwframe_ctx->height    = inlink->h;
 101
 102     ret = av_hwframe_ctx_init(s->hwframe);
 103     if (ret < 0)
 104         return ret;
 105
 106     outlink->hw_frames_ctx = av_buffer_ref(s->hwframe);
 107     if (!outlink->hw_frames_ctx)
 108         return AVERROR(ENOMEM);
 109
 110     return 0;
 111 }
 112
 113 static int cudaupload_filter_frame(AVFilterLink *link, AVFrame *in)
 114 {
 115     AVFilterContext   *ctx = link->dst;
 116     CudaUploadContext   *s = ctx->priv;
 117
 118     AVFrame *out = NULL;
 119     int ret;
 120
 121     out = av_frame_alloc();
 122     if (!out) {
 123         ret = AVERROR(ENOMEM);
 124         goto fail;
 125     }
 126
 127     ret = av_hwframe_get_buffer(s->hwframe, out, 0);
 128     if (ret < 0)
 129         goto fail;
 130
 131     out->width  = in->width;
 132     out->height = in->height;
 133
 134     ret = av_hwframe_transfer_data(out, in, 0);
 135     if (ret < 0) {
 136         av_log(ctx, AV_LOG_ERROR, "Error transferring data to the GPU\n");
 137         goto fail;
 138     }
 139
 140     ret = av_frame_copy_props(out, in);
 141     if (ret < 0)
 142         goto fail;
 143
 144     av_frame_free(&in);
 145
 146     return ff_filter_frame(ctx->outputs[0], out);
 147 fail:
 148     av_frame_free(&in);
 149     av_frame_free(&out);
 150     return ret;
 151 }
 152
 153 #define OFFSET(x) offsetof(CudaUploadContext, x)
 154 #define FLAGS (AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
 155 static const AVOption cudaupload_options[] = {
 156     { "device", "Number of the device to use", OFFSET(device_idx), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FLAGS },
 157     { NULL },
 158 };
 159
 160 AVFILTER_DEFINE_CLASS(cudaupload);
 161
 162 static const AVFilterPad cudaupload_inputs[] = {
 163     {
 164         .name         = "default",
 165         .type         = AVMEDIA_TYPE_VIDEO,
 166         .filter_frame = cudaupload_filter_frame,
 167     },
 168     { NULL }
 169 };
 170
 171 static const AVFilterPad cudaupload_outputs[] = {
 172     {
 173         .name         = "default",
 174         .type         = AVMEDIA_TYPE_VIDEO,
 175         .config_props = cudaupload_config_output,
 176     },
 177     { NULL }
 178 };
 179
 180 AVFilter ff_vf_hwupload_cuda = {
 181     .name        = "hwupload_cuda",
 182     .description = NULL_IF_CONFIG_SMALL("Upload a system memory frame to a CUDA device."),
 183
 184     .init      = cudaupload_init,
 185     .uninit    = cudaupload_uninit,
 186
 187     .query_formats = cudaupload_query_formats,
 188
 189     .priv_size  = sizeof(CudaUploadContext),
 190     .priv_class = &cudaupload_class,
 191
 192     .inputs    = cudaupload_inputs,
 193     .outputs   = cudaupload_outputs,
 194 };