| /* |
| * This file is part of FFmpeg. |
| * |
| * FFmpeg is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * FFmpeg is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with FFmpeg; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| */ |
| |
| #include "libavutil/hwcontext.h" |
| #include "libavutil/hwcontext_cuda.h" |
| |
| #include "ffmpeg.h" |
| |
| #include <cuda.h> |
| #include <nvcuvid.h> |
| |
| typedef struct CUVIDContext { |
| AVBufferRef *hw_frames_ctx; |
| } CUVIDContext; |
| |
| static void cuvid_uninit(AVCodecContext *avctx) |
| { |
| InputStream *ist = avctx->opaque; |
| CUVIDContext *ctx = ist->hwaccel_ctx; |
| |
| if (ctx) { |
| av_buffer_unref(&ctx->hw_frames_ctx); |
| av_freep(&ctx); |
| } |
| |
| av_buffer_unref(&ist->hw_frames_ctx); |
| |
| ist->hwaccel_ctx = 0; |
| ist->hwaccel_uninit = 0; |
| } |
| |
| int cuvid_init(AVCodecContext *avctx) |
| { |
| InputStream *ist = avctx->opaque; |
| CUVIDContext *ctx = ist->hwaccel_ctx; |
| |
| av_log(NULL, AV_LOG_TRACE, "Initializing cuvid hwaccel\n"); |
| |
| if (!ctx) { |
| av_log(NULL, AV_LOG_ERROR, "CUVID transcoding is not initialized. " |
| "-hwaccel cuvid should only be used for one-to-one CUVID transcoding " |
| "with no (software) filters.\n"); |
| return AVERROR(EINVAL); |
| } |
| |
| return 0; |
| } |
| |
| static void cuvid_ctx_free(AVHWDeviceContext *ctx) |
| { |
| AVCUDADeviceContext *hwctx = ctx->hwctx; |
| cuCtxDestroy(hwctx->cuda_ctx); |
| } |
| |
| int cuvid_transcode_init(OutputStream *ost) |
| { |
| InputStream *ist; |
| const enum AVPixelFormat *pix_fmt; |
| AVCUDADeviceContext *device_hwctx; |
| AVHWDeviceContext *device_ctx; |
| AVHWFramesContext *hwframe_ctx; |
| CUVIDContext *ctx = NULL; |
| CUdevice device; |
| CUcontext cuda_ctx = NULL; |
| CUcontext dummy; |
| CUresult err; |
| int ret = 0; |
| |
| av_log(NULL, AV_LOG_TRACE, "Initializing cuvid transcoding\n"); |
| |
| if (ost->source_index < 0) |
| return 0; |
| |
| ist = input_streams[ost->source_index]; |
| |
| /* check if the encoder supports CUVID */ |
| if (!ost->enc->pix_fmts) |
| goto cancel; |
| for (pix_fmt = ost->enc->pix_fmts; *pix_fmt != AV_PIX_FMT_NONE; pix_fmt++) |
| if (*pix_fmt == AV_PIX_FMT_CUDA) |
| break; |
| if (*pix_fmt == AV_PIX_FMT_NONE) |
| goto cancel; |
| |
| /* check if the decoder supports CUVID */ |
| if (ist->hwaccel_id != HWACCEL_CUVID || !ist->dec || !ist->dec->pix_fmts) |
| goto cancel; |
| for (pix_fmt = ist->dec->pix_fmts; *pix_fmt != AV_PIX_FMT_NONE; pix_fmt++) |
| if (*pix_fmt == AV_PIX_FMT_CUDA) |
| break; |
| if (*pix_fmt == AV_PIX_FMT_NONE) |
| goto cancel; |
| |
| av_log(NULL, AV_LOG_VERBOSE, "Setting up CUVID transcoding\n"); |
| |
| if (ist->hwaccel_ctx) { |
| ctx = ist->hwaccel_ctx; |
| } else { |
| ctx = av_mallocz(sizeof(*ctx)); |
| if (!ctx) { |
| ret = AVERROR(ENOMEM); |
| goto error; |
| } |
| } |
| |
| if (!hw_device_ctx) { |
| hw_device_ctx = av_hwdevice_ctx_alloc(AV_HWDEVICE_TYPE_CUDA); |
| if (!hw_device_ctx) { |
| av_log(NULL, AV_LOG_ERROR, "av_hwdevice_ctx_alloc(AV_HWDEVICE_TYPE_CUDA) failed\n"); |
| ret = AVERROR(ENOMEM); |
| goto error; |
| } |
| |
| err = cuInit(0); |
| if (err != CUDA_SUCCESS) { |
| av_log(NULL, AV_LOG_ERROR, "Could not initialize the CUDA driver API\n"); |
| ret = AVERROR_UNKNOWN; |
| goto error; |
| } |
| |
| err = cuDeviceGet(&device, 0); ///TODO: Make device index configurable |
| if (err != CUDA_SUCCESS) { |
| av_log(NULL, AV_LOG_ERROR, "Could not get the device number %d\n", 0); |
| ret = AVERROR_UNKNOWN; |
| goto error; |
| } |
| |
| err = cuCtxCreate(&cuda_ctx, CU_CTX_SCHED_BLOCKING_SYNC, device); |
| if (err != CUDA_SUCCESS) { |
| av_log(NULL, AV_LOG_ERROR, "Error creating a CUDA context\n"); |
| ret = AVERROR_UNKNOWN; |
| goto error; |
| } |
| |
| device_ctx = (AVHWDeviceContext*)hw_device_ctx->data; |
| device_ctx->free = cuvid_ctx_free; |
| |
| device_hwctx = device_ctx->hwctx; |
| device_hwctx->cuda_ctx = cuda_ctx; |
| |
| err = cuCtxPopCurrent(&dummy); |
| if (err != CUDA_SUCCESS) { |
| av_log(NULL, AV_LOG_ERROR, "cuCtxPopCurrent failed\n"); |
| ret = AVERROR_UNKNOWN; |
| goto error; |
| } |
| |
| ret = av_hwdevice_ctx_init(hw_device_ctx); |
| if (ret < 0) { |
| av_log(NULL, AV_LOG_ERROR, "av_hwdevice_ctx_init failed\n"); |
| goto error; |
| } |
| } else { |
| device_ctx = (AVHWDeviceContext*)hw_device_ctx->data; |
| device_hwctx = device_ctx->hwctx; |
| cuda_ctx = device_hwctx->cuda_ctx; |
| } |
| |
| if (device_ctx->type != AV_HWDEVICE_TYPE_CUDA) { |
| av_log(NULL, AV_LOG_ERROR, "Hardware device context is already initialized for a diffrent hwaccel.\n"); |
| ret = AVERROR(EINVAL); |
| goto error; |
| } |
| |
| if (!ctx->hw_frames_ctx) { |
| ctx->hw_frames_ctx = av_hwframe_ctx_alloc(hw_device_ctx); |
| if (!ctx->hw_frames_ctx) { |
| av_log(NULL, AV_LOG_ERROR, "av_hwframe_ctx_alloc failed\n"); |
| ret = AVERROR(ENOMEM); |
| goto error; |
| } |
| } |
| |
| /* This is a bit hacky, av_hwframe_ctx_init is called by the cuvid decoder |
| * once it has probed the neccesary format information. But as filters/nvenc |
| * need to know the format/sw_format, set them here so they are happy. |
| * This is fine as long as CUVID doesn't add another supported pix_fmt. |
| */ |
| hwframe_ctx = (AVHWFramesContext*)ctx->hw_frames_ctx->data; |
| hwframe_ctx->format = AV_PIX_FMT_CUDA; |
| hwframe_ctx->sw_format = AV_PIX_FMT_NV12; |
| |
| ost->hwaccel_ctx = ctx; |
| ost->enc_ctx->hw_frames_ctx = av_buffer_ref(ctx->hw_frames_ctx); |
| ost->enc_ctx->pix_fmt = AV_PIX_FMT_CUDA; |
| |
| if (!ost->enc_ctx->hw_frames_ctx) { |
| av_log(NULL, AV_LOG_ERROR, "av_buffer_ref failed\n"); |
| ret = AVERROR(ENOMEM); |
| goto error; |
| } |
| |
| if (!ist->hwaccel_ctx) { |
| ist->hwaccel_ctx = ctx; |
| ist->hw_frames_ctx = av_buffer_ref(ctx->hw_frames_ctx); |
| ist->dec_ctx->hw_frames_ctx = av_buffer_ref(ctx->hw_frames_ctx); |
| ist->dec_ctx->pix_fmt = AV_PIX_FMT_CUDA; |
| ist->resample_pix_fmt = AV_PIX_FMT_CUDA; |
| |
| ist->hwaccel_uninit = cuvid_uninit; |
| |
| if (!ist->hw_frames_ctx || !ist->dec_ctx->hw_frames_ctx) { |
| av_log(NULL, AV_LOG_ERROR, "av_buffer_ref failed\n"); |
| ret = AVERROR(ENOMEM); |
| goto error; |
| } |
| } |
| |
| return 0; |
| |
| error: |
| av_freep(&ctx); |
| return ret; |
| |
| cancel: |
| if (ist->hwaccel_id == HWACCEL_CUVID) { |
| av_log(NULL, AV_LOG_ERROR, "CUVID hwaccel requested, but impossible to achive.\n"); |
| return AVERROR(EINVAL); |
| } |
| |
| return 0; |
| } |