ffmpeg_cuvid: Don't unnecessarily include nvcuvid.h
[ffmpeg.git] / ffmpeg_cuvid.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/hwcontext.h"
20 #include "libavutil/hwcontext_cuda.h"
21
22 #include "ffmpeg.h"
23
24 #include <cuda.h>
25
26 typedef struct CUVIDContext {
27     AVBufferRef *hw_frames_ctx;
28 } CUVIDContext;
29
30 static void cuvid_uninit(AVCodecContext *avctx)
31 {
32     InputStream  *ist = avctx->opaque;
33     CUVIDContext *ctx = ist->hwaccel_ctx;
34
35     if (ctx) {
36         av_buffer_unref(&ctx->hw_frames_ctx);
37         av_freep(&ctx);
38     }
39
40     av_buffer_unref(&ist->hw_frames_ctx);
41
42     ist->hwaccel_ctx = 0;
43     ist->hwaccel_uninit = 0;
44 }
45
46 int cuvid_init(AVCodecContext *avctx)
47 {
48     InputStream  *ist = avctx->opaque;
49     CUVIDContext *ctx = ist->hwaccel_ctx;
50
51     av_log(NULL, AV_LOG_TRACE, "Initializing cuvid hwaccel\n");
52
53     if (!ctx) {
54         av_log(NULL, AV_LOG_ERROR, "CUVID transcoding is not initialized. "
55                "-hwaccel cuvid should only be used for one-to-one CUVID transcoding "
56                "with no (software) filters.\n");
57         return AVERROR(EINVAL);
58     }
59
60     return 0;
61 }
62
63 static void cuvid_ctx_free(AVHWDeviceContext *ctx)
64 {
65     AVCUDADeviceContext *hwctx = ctx->hwctx;
66     cuCtxDestroy(hwctx->cuda_ctx);
67 }
68
69 int cuvid_transcode_init(OutputStream *ost)
70 {
71     InputStream *ist;
72     const enum AVPixelFormat *pix_fmt;
73     AVCUDADeviceContext *device_hwctx;
74     AVHWDeviceContext *device_ctx;
75     AVHWFramesContext *hwframe_ctx;
76     CUVIDContext *ctx = NULL;
77     CUdevice device;
78     CUcontext cuda_ctx = NULL;
79     CUcontext dummy;
80     CUresult err;
81     int ret = 0;
82
83     av_log(NULL, AV_LOG_TRACE, "Initializing cuvid transcoding\n");
84
85     if (ost->source_index < 0)
86         return 0;
87
88     ist = input_streams[ost->source_index];
89
90     /* check if the encoder supports CUVID */
91     if (!ost->enc->pix_fmts)
92         goto cancel;
93     for (pix_fmt = ost->enc->pix_fmts; *pix_fmt != AV_PIX_FMT_NONE; pix_fmt++)
94         if (*pix_fmt == AV_PIX_FMT_CUDA)
95             break;
96     if (*pix_fmt == AV_PIX_FMT_NONE)
97         goto cancel;
98
99     /* check if the decoder supports CUVID */
100     if (ist->hwaccel_id != HWACCEL_CUVID || !ist->dec || !ist->dec->pix_fmts)
101         goto cancel;
102     for (pix_fmt = ist->dec->pix_fmts; *pix_fmt != AV_PIX_FMT_NONE; pix_fmt++)
103         if (*pix_fmt == AV_PIX_FMT_CUDA)
104             break;
105     if (*pix_fmt == AV_PIX_FMT_NONE)
106         goto cancel;
107
108     av_log(NULL, AV_LOG_VERBOSE, "Setting up CUVID transcoding\n");
109
110     if (ist->hwaccel_ctx) {
111         ctx = ist->hwaccel_ctx;
112     } else {
113         ctx = av_mallocz(sizeof(*ctx));
114         if (!ctx) {
115             ret = AVERROR(ENOMEM);
116             goto error;
117         }
118     }
119
120     if (!hw_device_ctx) {
121         hw_device_ctx = av_hwdevice_ctx_alloc(AV_HWDEVICE_TYPE_CUDA);
122         if (!hw_device_ctx) {
123             av_log(NULL, AV_LOG_ERROR, "av_hwdevice_ctx_alloc(AV_HWDEVICE_TYPE_CUDA) failed\n");
124             ret = AVERROR(ENOMEM);
125             goto error;
126         }
127
128         err = cuInit(0);
129         if (err != CUDA_SUCCESS) {
130             av_log(NULL, AV_LOG_ERROR, "Could not initialize the CUDA driver API\n");
131             ret = AVERROR_UNKNOWN;
132             goto error;
133         }
134
135         err = cuDeviceGet(&device, 0); ///TODO: Make device index configurable
136         if (err != CUDA_SUCCESS) {
137             av_log(NULL, AV_LOG_ERROR, "Could not get the device number %d\n", 0);
138             ret = AVERROR_UNKNOWN;
139             goto error;
140         }
141
142         err = cuCtxCreate(&cuda_ctx, CU_CTX_SCHED_BLOCKING_SYNC, device);
143         if (err != CUDA_SUCCESS) {
144             av_log(NULL, AV_LOG_ERROR, "Error creating a CUDA context\n");
145             ret = AVERROR_UNKNOWN;
146             goto error;
147         }
148
149         device_ctx = (AVHWDeviceContext*)hw_device_ctx->data;
150         device_ctx->free = cuvid_ctx_free;
151
152         device_hwctx = device_ctx->hwctx;
153         device_hwctx->cuda_ctx = cuda_ctx;
154
155         err = cuCtxPopCurrent(&dummy);
156         if (err != CUDA_SUCCESS) {
157             av_log(NULL, AV_LOG_ERROR, "cuCtxPopCurrent failed\n");
158             ret = AVERROR_UNKNOWN;
159             goto error;
160         }
161
162         ret = av_hwdevice_ctx_init(hw_device_ctx);
163         if (ret < 0) {
164             av_log(NULL, AV_LOG_ERROR, "av_hwdevice_ctx_init failed\n");
165             goto error;
166         }
167     } else {
168         device_ctx = (AVHWDeviceContext*)hw_device_ctx->data;
169         device_hwctx = device_ctx->hwctx;
170         cuda_ctx = device_hwctx->cuda_ctx;
171     }
172
173     if (device_ctx->type != AV_HWDEVICE_TYPE_CUDA) {
174         av_log(NULL, AV_LOG_ERROR, "Hardware device context is already initialized for a diffrent hwaccel.\n");
175         ret = AVERROR(EINVAL);
176         goto error;
177     }
178
179     if (!ctx->hw_frames_ctx) {
180         ctx->hw_frames_ctx = av_hwframe_ctx_alloc(hw_device_ctx);
181         if (!ctx->hw_frames_ctx) {
182             av_log(NULL, AV_LOG_ERROR, "av_hwframe_ctx_alloc failed\n");
183             ret = AVERROR(ENOMEM);
184             goto error;
185         }
186     }
187
188     /* This is a bit hacky, av_hwframe_ctx_init is called by the cuvid decoder
189      * once it has probed the neccesary format information. But as filters/nvenc
190      * need to know the format/sw_format, set them here so they are happy.
191      * This is fine as long as CUVID doesn't add another supported pix_fmt.
192      */
193     hwframe_ctx = (AVHWFramesContext*)ctx->hw_frames_ctx->data;
194     hwframe_ctx->format = AV_PIX_FMT_CUDA;
195     hwframe_ctx->sw_format = AV_PIX_FMT_NV12;
196
197     ost->hwaccel_ctx = ctx;
198     ost->enc_ctx->hw_frames_ctx = av_buffer_ref(ctx->hw_frames_ctx);
199     ost->enc_ctx->pix_fmt = AV_PIX_FMT_CUDA;
200
201     if (!ost->enc_ctx->hw_frames_ctx) {
202         av_log(NULL, AV_LOG_ERROR, "av_buffer_ref failed\n");
203         ret = AVERROR(ENOMEM);
204         goto error;
205     }
206
207     if (!ist->hwaccel_ctx) {
208         ist->hwaccel_ctx = ctx;
209         ist->hw_frames_ctx = av_buffer_ref(ctx->hw_frames_ctx);
210         ist->dec_ctx->hw_frames_ctx = av_buffer_ref(ctx->hw_frames_ctx);
211         ist->dec_ctx->pix_fmt = AV_PIX_FMT_CUDA;
212         ist->resample_pix_fmt = AV_PIX_FMT_CUDA;
213
214         ist->hwaccel_uninit = cuvid_uninit;
215
216         if (!ist->hw_frames_ctx || !ist->dec_ctx->hw_frames_ctx) {
217             av_log(NULL, AV_LOG_ERROR, "av_buffer_ref failed\n");
218             ret = AVERROR(ENOMEM);
219             goto error;
220         }
221     }
222
223     return 0;
224
225 error:
226     av_freep(&ctx);
227     return ret;
228
229 cancel:
230     if (ist->hwaccel_id == HWACCEL_CUVID) {
231         av_log(NULL, AV_LOG_ERROR, "CUVID hwaccel requested, but impossible to achive.\n");
232         return AVERROR(EINVAL);
233     }
234
235     return 0;
236 }