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