lavfi/dynaudnorm: rename pow2 to pow_2
[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;
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 };