avcodec/mlpdsp: Fix runtime error: signed integer overflow: -24419392 * 128 cannot...
[ffmpeg.git] / ffmpeg_cuvid.c
index 866f43b..3ff3b40 100644 (file)
  */
 
 #include "libavutil/hwcontext.h"
-#include "libavutil/hwcontext_cuda.h"
+#include "libavutil/pixdesc.h"
 
 #include "ffmpeg.h"
 
-#include <cuda.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);
-    }
-
+    InputStream *ist = avctx->opaque;
     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");
+    InputStream *ist = avctx->opaque;
+    AVHWFramesContext *frames_ctx;
+    int ret;
 
-    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;
-        }
-    }
+    av_log(avctx, AV_LOG_VERBOSE, "Initializing cuvid hwaccel\n");
 
     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);
+        ret = av_hwdevice_ctx_create(&hw_device_ctx, AV_HWDEVICE_TYPE_CUDA,
+                                     ist->hwaccel_device, NULL, 0);
         if (ret < 0) {
-            av_log(NULL, AV_LOG_ERROR, "av_hwdevice_ctx_init failed\n");
-            goto error;
+            av_log(avctx, AV_LOG_ERROR, "Error creating a CUDA device\n");
+            return ret;
         }
-    } 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;
-        }
+    av_buffer_unref(&ist->hw_frames_ctx);
+    ist->hw_frames_ctx = av_hwframe_ctx_alloc(hw_device_ctx);
+    if (!ist->hw_frames_ctx) {
+        av_log(avctx, AV_LOG_ERROR, "Error creating a CUDA frames context\n");
+        return AVERROR(ENOMEM);
     }
 
-    /* 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;
-    }
+    frames_ctx = (AVHWFramesContext*)ist->hw_frames_ctx->data;
 
-    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;
+    frames_ctx->format = AV_PIX_FMT_CUDA;
+    frames_ctx->sw_format = avctx->sw_pix_fmt;
+    frames_ctx->width = avctx->width;
+    frames_ctx->height = avctx->height;
 
-        ist->hwaccel_uninit = cuvid_uninit;
+    av_log(avctx, AV_LOG_DEBUG, "Initializing CUDA frames context: sw_format = %s, width = %d, height = %d\n",
+           av_get_pix_fmt_name(frames_ctx->sw_format), frames_ctx->width, frames_ctx->height);
 
-        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;
-        }
+    ret = av_hwframe_ctx_init(ist->hw_frames_ctx);
+    if (ret < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Error initializing a CUDA frame pool\n");
+        return ret;
     }
 
-    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);
-    }
+    ist->hwaccel_uninit = cuvid_uninit;
 
     return 0;
 }