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 = ff_make_format_list(output_pix_fmts);
  68
  69     ret = ff_formats_ref(in_fmts, &ctx->inputs[0]->out_formats);
  70     if (ret < 0)
  71         return ret;
  72
  73     ret = ff_formats_ref(out_fmts, &ctx->outputs[0]->in_formats);
  74     if (ret < 0)
  75         return ret;
  76
  77     return 0;
  78 }
  79
  80 static int cudaupload_config_output(AVFilterLink *outlink)
  81 {
  82     AVFilterContext *ctx = outlink->src;
  83     AVFilterLink *inlink = ctx->inputs[0];
  84     CudaUploadContext *s = ctx->priv;
  85
  86     AVHWFramesContext *hwframe_ctx;
  87     int ret;
  88
  89     av_buffer_unref(&s->hwframe);
  90     s->hwframe = av_hwframe_ctx_alloc(s->hwdevice);
  91     if (!s->hwframe)
  92         return AVERROR(ENOMEM);
  93
  94     hwframe_ctx            = (AVHWFramesContext*)s->hwframe->data;
  95     hwframe_ctx->format    = AV_PIX_FMT_CUDA;
  96     hwframe_ctx->sw_format = inlink->format;
  97     hwframe_ctx->width     = inlink->w;
  98     hwframe_ctx->height    = inlink->h;
  99
 100     ret = av_hwframe_ctx_init(s->hwframe);
 101     if (ret < 0)
 102         return ret;
 103
 104     outlink->hw_frames_ctx = av_buffer_ref(s->hwframe);
 105     if (!outlink->hw_frames_ctx)
 106         return AVERROR(ENOMEM);
 107
 108     return 0;
 109 }
 110
 111 static int cudaupload_filter_frame(AVFilterLink *link, AVFrame *in)
 112 {
 113     AVFilterContext   *ctx = link->dst;
 114     CudaUploadContext   *s = ctx->priv;
 115
 116     AVFrame *out = NULL;
 117     int ret;
 118
 119     out = av_frame_alloc();
 120     if (!out) {
 121         ret = AVERROR(ENOMEM);
 122         goto fail;
 123     }
 124
 125     ret = av_hwframe_get_buffer(s->hwframe, out, 0);
 126     if (ret < 0)
 127         goto fail;
 128
 129     out->width  = in->width;
 130     out->height = in->height;
 131
 132     ret = av_hwframe_transfer_data(out, in, 0);
 133     if (ret < 0) {
 134         av_log(ctx, AV_LOG_ERROR, "Error transferring data to the GPU\n");
 135         goto fail;
 136     }
 137
 138     ret = av_frame_copy_props(out, in);
 139     if (ret < 0)
 140         goto fail;
 141
 142     av_frame_free(&in);
 143
 144     return ff_filter_frame(ctx->outputs[0], out);
 145 fail:
 146     av_frame_free(&in);
 147     av_frame_free(&out);
 148     return ret;
 149 }
 150
 151 #define OFFSET(x) offsetof(CudaUploadContext, x)
 152 #define FLAGS (AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
 153 static const AVOption cudaupload_options[] = {
 154     { "device", "Number of the device to use", OFFSET(device_idx), AV_OPT_TYPE_INT, { .i64 = 0 }, .flags = FLAGS },
 155     { NULL },
 156 };
 157
 158 AVFILTER_DEFINE_CLASS(cudaupload);
 159
 160 static const AVFilterPad cudaupload_inputs[] = {
 161     {
 162         .name         = "default",
 163         .type         = AVMEDIA_TYPE_VIDEO,
 164         .filter_frame = cudaupload_filter_frame,
 165     },
 166     { NULL }
 167 };
 168
 169 static const AVFilterPad cudaupload_outputs[] = {
 170     {
 171         .name         = "default",
 172         .type         = AVMEDIA_TYPE_VIDEO,
 173         .config_props = cudaupload_config_output,
 174     },
 175     { NULL }
 176 };
 177
 178 AVFilter ff_vf_hwupload_cuda = {
 179     .name        = "hwupload_cuda",
 180     .description = NULL_IF_CONFIG_SMALL("Upload a system memory frame to a CUDA device."),
 181
 182     .init      = cudaupload_init,
 183     .uninit    = cudaupload_uninit,
 184
 185     .query_formats = cudaupload_query_formats,
 186
 187     .priv_size  = sizeof(CudaUploadContext),
 188     .priv_class = &cudaupload_class,
 189
 190     .inputs    = cudaupload_inputs,
 191     .outputs   = cudaupload_outputs,
 192 };