avfilter/vf_hwupload_cuda: check ff_formats_ref for errors
[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     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 };