/*
  * 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;
 }