Address cmake errors, build warnings and use codec supported by windows ffmpeg.dll in perf tests.

Author: cudawarped

modules/cudacodec/CMakeLists.txt

@@ -6,20 +6,30 @@ set(the_description "CUDA-accelerated Video Encoding/Decoding")
 
 ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4127 /wd4324 /wd4512 -Wundef -Wshadow)
 
-ocv_add_module(cudacodec opencv_core opencv_videoio opencv_cudaarithm opencv_cudawarping OPTIONAL opencv_cudev WRAP python)
+set(required_dependencies opencv_core opencv_videoio opencv_cudaarithm opencv_cudawarping)
+if(HAVE_NVCUVENC)
+  list(APPEND required_dependencies opencv_cudaimgproc)
+endif()
+
+ocv_add_module(cudacodec ${required_dependencies} OPTIONAL opencv_cudev WRAP python)
 
 ocv_module_include_directories()
 ocv_glob_module_sources()
 
 set(extra_libs "")
 
-if(HAVE_NVCUVID)
-  list(APPEND extra_libs ${CUDA_CUDA_LIBRARY} ${CUDA_nvcuvid_LIBRARY})
-endif()
-
-if(HAVE_NVCUVENC)
-    list(APPEND extra_libs ${CUDA_CUDA_LIBRARY}  ${CUDA_nvencodeapi_LIBRARY})
-    ocv_add_module(cudacodec opencv_cudaimgproc)
+if(HAVE_NVCUVID OR HAVE_NVCUVENC)
+  list(APPEND extra_libs ${CUDA_CUDA_LIBRARY})
+  if(HAVE_NVCUVID)
+    list(APPEND extra_libs ${CUDA_nvcuvid_LIBRARY})
+  endif()
+  if(HAVE_NVCUVENC)
+      if(WIN32)
+        list(APPEND extra_libs ${CUDA_nvencodeapi_LIBRARY})
+      else()
+        list(APPEND extra_libs ${CUDA_nvidia-encode_LIBRARY})
+      endif()
+  endif()
 endif()
 
 ocv_create_module(${extra_libs})

modules/cudacodec/include/opencv2/cudacodec.hpp

@@ -184,7 +184,7 @@ struct CV_EXPORTS_W_SIMPLE EncoderParams
     CV_PROP_RW ENC_QP constQp; //!< QP's for ENC_PARAMS_RC_CONSTQP.
     CV_PROP_RW int averageBitRate; //!< target bitrate for ENC_PARAMS_RC_VBR and ENC_PARAMS_RC_CBR.
     CV_PROP_RW int maxBitRate; //!< upper bound on bitrate for ENC_PARAMS_RC_VBR and ENC_PARAMS_RC_CONSTQP.
-    CV_PROP_RW float targetQuality; //!< value 0 - 51 where video quality decreases as targetQuality increases, used with ENC_PARAMS_RC_VBR.
+    CV_PROP_RW uint8_t targetQuality; //!< value 0 - 51 where video quality decreases as targetQuality increases, used with ENC_PARAMS_RC_VBR.
     CV_PROP_RW int gopLength;
 };
 CV_EXPORTS bool operator==(const EncoderParams& lhs, const EncoderParams& rhs);
@@ -257,8 +257,8 @@ CV_EXPORTS_W Ptr<cudacodec::VideoWriter> createVideoWriter(const String& fileNam
 @param bufferFormat Nvidia Video Codec SDK buffer format of the frames to be encoded.
 @param stream Stream for frame pre-processing.
 */
-CV_EXPORTS_W Ptr<cudacodec::VideoWriter> createVideoWriter(const String& fileName, const Size frameSize, const VideoWriterCodec codec = VideoWriterCodec::H264,
-    const double fps = 25.0, const ENC_BUFFER_FORMAT bufferFormat = BF_ARGB, const Stream& stream = Stream::Null());
+CV_EXPORTS_W Ptr<cudacodec::VideoWriter> createVideoWriter(const String& fileName, const Size frameSize, const VideoWriterCodec codec,
+    const double fps, const ENC_BUFFER_FORMAT bufferFormat, const Stream& stream = Stream::Null());
 
 /** @brief Creates video writer.
 
@@ -312,8 +312,8 @@ CV_EXPORTS_W Ptr<cudacodec::VideoWriter> createVideoWriter(const Ptr<EncoderCall
 
 The constructors initialize video writer. User can implement their own multiplexing with cudacodec::EncoderCallback.
 */
-CV_EXPORTS_W Ptr<cudacodec::VideoWriter> createVideoWriter(const Ptr<EncoderCallback>& encoderCallback, const Size frameSize, const VideoWriterCodec codec = VideoWriterCodec::H264,
-    const double fps = 25.0, const ENC_BUFFER_FORMAT bufferFormat = BF_ARGB, const Stream& stream = Stream::Null());
+CV_EXPORTS_W Ptr<cudacodec::VideoWriter> createVideoWriter(const Ptr<EncoderCallback>& encoderCallback, const Size frameSize, const VideoWriterCodec codec,
+    const double fps, const ENC_BUFFER_FORMAT bufferFormat, const Stream& stream = Stream::Null());
 
 /** @brief Creates video writer.
 

modules/cudacodec/perf/perf_video.cpp

@@ -167,7 +167,7 @@ PERF_TEST_P(WriteToFile, VideoWriter, Combine(VIDEO_SRC, COLOR_FORMAT, CODEC))
             reader >> frameBgr;
             ASSERT_FALSE(frameBgr.empty());
             if (!writer.isOpened())
-                writer.open(outputFile, VideoWriter::fourcc('x', '2', '6', '4'), fps, frameBgr.size());
+                writer.open(outputFile, VideoWriter::fourcc('X', 'V', 'I', 'D'), fps, frameBgr.size());
             startTimer();
             writer.write(frameBgr);
             stopTimer();

modules/cudacodec/src/NvEncoder.cpp

@@ -38,7 +38,8 @@ NvEncoder::NvEncoder(NV_ENC_DEVICE_TYPE eDeviceType, void* pDevice, uint32_t nWi
         NVENC_THROW_ERROR("EncodeAPI not found", NV_ENC_ERR_NO_ENCODE_DEVICE);
     }
 
-    NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS encodeSessionExParams = { NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS_VER };
+    NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS encodeSessionExParams = {};
+    encodeSessionExParams.version = NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS_VER;
     encodeSessionExParams.device = m_pDevice;
     encodeSessionExParams.deviceType = m_eDeviceType;
     encodeSessionExParams.apiVersion = NVENCAPI_VERSION;
@@ -58,8 +59,8 @@ void NvEncoder::LoadNvEncApi()
         NVENC_THROW_ERROR("Current Driver Version does not support this NvEncodeAPI version, please upgrade driver", NV_ENC_ERR_INVALID_VERSION);
     }
 
-
-    m_nvenc = { NV_ENCODE_API_FUNCTION_LIST_VER };
+    m_nvenc = {};
+    m_nvenc.version = NV_ENCODE_API_FUNCTION_LIST_VER;
     NVENC_API_CALL(NvEncodeAPICreateInstance(&m_nvenc));
 }
 
@@ -109,7 +110,9 @@ void NvEncoder::CreateDefaultEncoderParams(NV_ENC_INITIALIZE_PARAMS* pIntializeP
     pIntializeParams->enableEncodeAsync = GetCapabilityValue(codecGuid, NV_ENC_CAPS_ASYNC_ENCODE_SUPPORT);
 #endif
     pIntializeParams->tuningInfo = tuningInfo;
-    NV_ENC_PRESET_CONFIG presetConfig = { NV_ENC_PRESET_CONFIG_VER, { NV_ENC_CONFIG_VER } };
+    NV_ENC_PRESET_CONFIG presetConfig = {};
+    presetConfig.version = NV_ENC_PRESET_CONFIG_VER;
+    presetConfig.presetCfg.version = NV_ENC_CONFIG_VER;
     m_nvenc.nvEncGetEncodePresetConfigEx(m_hEncoder, codecGuid, presetGuid, tuningInfo, &presetConfig);
     memcpy(pIntializeParams->encodeConfig, &presetConfig.presetCfg, sizeof(NV_ENC_CONFIG));
 
@@ -200,7 +203,9 @@ void NvEncoder::CreateEncoder(const NV_ENC_INITIALIZE_PARAMS* pEncoderParams)
     }
     else
     {
-        NV_ENC_PRESET_CONFIG presetConfig = { NV_ENC_PRESET_CONFIG_VER, { NV_ENC_CONFIG_VER } };
+        NV_ENC_PRESET_CONFIG presetConfig = {};
+        presetConfig.version = NV_ENC_PRESET_CONFIG_VER;
+        presetConfig.presetCfg.version = NV_ENC_CONFIG_VER;
         m_nvenc.nvEncGetEncodePresetConfigEx(m_hEncoder, pEncoderParams->encodeGUID, pEncoderParams->presetGUID, pEncoderParams->tuningInfo, &presetConfig);
         memcpy(&m_encodeConfig, &presetConfig.presetCfg, sizeof(NV_ENC_CONFIG));
     }
@@ -283,8 +288,8 @@ const NvEncInputFrame* NvEncoder::GetNextInputFrame()
 
 void NvEncoder::MapResources(uint32_t bfrIdx)
 {
-    NV_ENC_MAP_INPUT_RESOURCE mapInputResource = { NV_ENC_MAP_INPUT_RESOURCE_VER };
-
+    NV_ENC_MAP_INPUT_RESOURCE mapInputResource = {};
+    mapInputResource.version = NV_ENC_MAP_INPUT_RESOURCE_VER;
     mapInputResource.registeredResource = m_vRegisteredResources[bfrIdx];
     NVENC_API_CALL(m_nvenc.nvEncMapInputResource(m_hEncoder, &mapInputResource));
     m_vMappedInputBuffers[bfrIdx] = mapInputResource.mappedResource;
@@ -319,7 +324,8 @@ void NvEncoder::GetSequenceParams(std::vector<uint8_t>& seqParams)
 {
     uint8_t spsppsData[1024]; // Assume maximum spspps data is 1KB or less
     memset(spsppsData, 0, sizeof(spsppsData));
-    NV_ENC_SEQUENCE_PARAM_PAYLOAD payload = { NV_ENC_SEQUENCE_PARAM_PAYLOAD_VER };
+    NV_ENC_SEQUENCE_PARAM_PAYLOAD payload = {};
+    payload.version = NV_ENC_SEQUENCE_PARAM_PAYLOAD_VER;
     uint32_t spsppsSize = 0;
 
     payload.spsppsBuffer = spsppsData;
@@ -352,7 +358,9 @@ NVENCSTATUS NvEncoder::DoEncode(NV_ENC_INPUT_PTR inputBuffer, NV_ENC_OUTPUT_PTR
 
 void NvEncoder::SendEOS()
 {
-    NV_ENC_PIC_PARAMS picParams = { NV_ENC_PIC_PARAMS_VER };
+    NV_ENC_PIC_PARAMS picParams = {};
+    picParams.version = NV_ENC_PIC_PARAMS_VER;
+
     picParams.encodePicFlags = NV_ENC_PIC_FLAG_EOS;
     picParams.completionEvent = GetCompletionEvent(m_iToSend % m_nEncoderBuffer);
     NVENC_API_CALL(m_nvenc.nvEncEncodePicture(m_hEncoder, &picParams));
@@ -378,7 +386,8 @@ void NvEncoder::GetEncodedPacket(std::vector<NV_ENC_OUTPUT_PTR>& vOutputBuffer,
     for (; m_iGot < iEnd; m_iGot++)
     {
         WaitForCompletionEvent(m_iGot % m_nEncoderBuffer);
-        NV_ENC_LOCK_BITSTREAM lockBitstreamData = { NV_ENC_LOCK_BITSTREAM_VER };
+        NV_ENC_LOCK_BITSTREAM lockBitstreamData = {};
+        lockBitstreamData.version = NV_ENC_LOCK_BITSTREAM_VER;
         lockBitstreamData.outputBitstream = vOutputBuffer[m_iGot % m_nEncoderBuffer];
         lockBitstreamData.doNotWait = false;
         NVENC_API_CALL(m_nvenc.nvEncLockBitstream(m_hEncoder, &lockBitstreamData));
@@ -424,7 +433,8 @@ NV_ENC_REGISTERED_PTR NvEncoder::RegisterResource(void* pBuffer, NV_ENC_INPUT_RE
     int width, int height, int pitch, NV_ENC_BUFFER_FORMAT bufferFormat, NV_ENC_BUFFER_USAGE bufferUsage,
     NV_ENC_FENCE_POINT_D3D12* pInputFencePoint, NV_ENC_FENCE_POINT_D3D12* pOutputFencePoint)
 {
-    NV_ENC_REGISTER_RESOURCE registerResource = { NV_ENC_REGISTER_RESOURCE_VER };
+    NV_ENC_REGISTER_RESOURCE registerResource = {};
+    registerResource.version = NV_ENC_REGISTER_RESOURCE_VER;
     registerResource.resourceType = eResourceType;
     registerResource.resourceToRegister = pBuffer;
     registerResource.width = width;
@@ -569,7 +579,6 @@ uint32_t NvEncoder::GetWidthInBytes(const NV_ENC_BUFFER_FORMAT bufferFormat, con
         return width * 4;
     default:
         NVENC_THROW_ERROR("Invalid Buffer format", NV_ENC_ERR_INVALID_PARAM);
-        return 0;
     }
 }
 
@@ -646,7 +655,6 @@ void NvEncoder::GetChromaSubPlaneOffsets(const NV_ENC_BUFFER_FORMAT bufferFormat
         return;
     default:
         NVENC_THROW_ERROR("Invalid Buffer format", NV_ENC_ERR_INVALID_PARAM);
-        return;
     }
 }
 
@@ -670,7 +678,6 @@ uint32_t NvEncoder::GetChromaHeight(const NV_ENC_BUFFER_FORMAT bufferFormat, con
         return 0;
     default:
         NVENC_THROW_ERROR("Invalid Buffer format", NV_ENC_ERR_INVALID_PARAM);
-        return 0;
     }
 }
 
@@ -697,7 +704,6 @@ uint32_t NvEncoder::GetChromaWidthInBytes(const NV_ENC_BUFFER_FORMAT bufferForma
         return 0;
     default:
         NVENC_THROW_ERROR("Invalid Buffer format", NV_ENC_ERR_INVALID_PARAM);
-        return 0;
     }
 }
 
@@ -708,7 +714,8 @@ int NvEncoder::GetCapabilityValue(GUID guidCodec, NV_ENC_CAPS capsToQuery)
     {
         return 0;
     }
-    NV_ENC_CAPS_PARAM capsParam = { NV_ENC_CAPS_PARAM_VER };
+    NV_ENC_CAPS_PARAM capsParam = {};
+    capsParam.version = NV_ENC_CAPS_PARAM_VER;
     capsParam.capsToQuery = capsToQuery;
     int v;
     m_nvenc.nvEncGetEncodeCaps(m_hEncoder, guidCodec, &capsParam, &v);
@@ -737,7 +744,6 @@ int NvEncoder::GetFrameSize() const
         return 4 * GetEncodeWidth() * GetEncodeHeight();
     default:
         NVENC_THROW_ERROR("Invalid Buffer format", NV_ENC_ERR_INVALID_PARAM);
-        return 0;
     }
 }
 
@@ -757,7 +763,8 @@ void NvEncoder::InitializeBitstreamBuffer()
 {
     for (int i = 0; i < m_nEncoderBuffer; i++)
     {
-        NV_ENC_CREATE_BITSTREAM_BUFFER createBitstreamBuffer = { NV_ENC_CREATE_BITSTREAM_BUFFER_VER };
+        NV_ENC_CREATE_BITSTREAM_BUFFER createBitstreamBuffer = {};
+        createBitstreamBuffer.version = NV_ENC_CREATE_BITSTREAM_BUFFER_VER;
         NVENC_API_CALL(m_nvenc.nvEncCreateBitstreamBuffer(m_hEncoder, &createBitstreamBuffer));
         m_vBitstreamOutputBuffer[i] = createBitstreamBuffer.bitstreamBuffer;
     }

modules/cudacodec/src/NvEncoderCuda.cpp

@@ -130,7 +130,7 @@ void NvEncoderCuda::CopyToDeviceFrame(CUcontext device,
     cuSafeCall(cuCtxPushCurrent(device));
 
     uint32_t srcPitch = nSrcPitch ? nSrcPitch : NvEncoder::GetWidthInBytes(pixelFormat, width);
-    CUDA_MEMCPY2D m = { 0 };
+    CUDA_MEMCPY2D m = {};
     m.srcMemoryType = srcMemoryType;
     if (srcMemoryType == CU_MEMORYTYPE_HOST)
     {

modules/cudacodec/src/video_writer.cpp

@@ -59,6 +59,15 @@ Ptr<cudacodec::VideoWriter> createVideoWriter(const Ptr<EncoderCallback>&, const
 
 #else // !defined HAVE_NVCUVENC
 
+ENC_BUFFER_FORMAT NvSurfaceFormat(const COLOR_FORMAT_CV format);
+int NChannels(const COLOR_FORMAT_CV format);
+int NChannels(const ENC_BUFFER_FORMAT format);
+GUID CodecGuid(const VideoWriterCodec codec);
+void FrameRate(const double fps, uint32_t& frameRateNum, uint32_t& frameRateDen);
+GUID EncodingProfileGuid(const ENC_PROFILE encodingProfile);
+GUID EncodingPresetGuid(const ENC_PRESET nvPreset);
+bool Equal(const GUID& g1, const GUID& g2);
+
 EncoderParams::EncoderParams() : nvPreset(ENC_PRESET_P3), tuningInfo(ENC_TUNING_INFO_HIGH_QUALITY), encodingProfile(ENC_CODEC_PROFILE_AUTOSELECT),
     rateControlMode(ENC_PARAMS_RC_VBR), multiPassEncoding(ENC_MULTI_PASS_DISABLED), constQp({ 0,0,0 }), averageBitRate(0), maxBitRate(0),
     targetQuality(30), gopLength(0)
@@ -119,7 +128,7 @@ class VideoWriterImpl : public VideoWriter
     void close();
 private:
     void Init(const VideoWriterCodec codec, const double fps, const Size frameSz);
-    void InitializeEncoder(NvEncoderCuda* const pEnc, const GUID codec, const double fps);
+    void InitializeEncoder(const GUID codec, const double fps);
     void CopyToNvSurface(const InputArray src);
 
     Ptr<EncoderCallback> encoderCallback;
@@ -225,7 +234,7 @@ void VideoWriterImpl::Init(const VideoWriterCodec codec, const double fps, const
     const GUID codecGuid = CodecGuid(codec);
     try {
         pEnc = new NvEncoderCuda(cuContext, frameSz.width, frameSz.height, (NV_ENC_BUFFER_FORMAT)surfaceFormatNv);
-        InitializeEncoder(pEnc, codecGuid, fps);
+        InitializeEncoder(codecGuid, fps);
         const cudaStream_t cudaStream = cuda::StreamAccessor::getStream(stream);
         pEnc->SetIOCudaStreams((NV_ENC_CUSTREAM_PTR)&cudaStream, (NV_ENC_CUSTREAM_PTR)&cudaStream);
     }
@@ -294,10 +303,12 @@ bool Equal(const GUID& g1, const GUID& g2) {
     return false;
 }
 
-void VideoWriterImpl::InitializeEncoder(NvEncoderCuda* const pEnc, const GUID codec, const double fps)
+void VideoWriterImpl::InitializeEncoder(const GUID codec, const double fps)
 {
-    NV_ENC_INITIALIZE_PARAMS initializeParams = { NV_ENC_INITIALIZE_PARAMS_VER };
-    NV_ENC_CONFIG encodeConfig = { NV_ENC_CONFIG_VER };
+    NV_ENC_INITIALIZE_PARAMS initializeParams = {};
+    initializeParams.version = NV_ENC_INITIALIZE_PARAMS_VER;
+    NV_ENC_CONFIG encodeConfig = {};
+    encodeConfig.version = NV_ENC_CONFIG_VER;
     initializeParams.encodeConfig = &encodeConfig;
     pEnc->CreateDefaultEncoderParams(&initializeParams, codec, EncodingPresetGuid(encoderParams.nvPreset), (NV_ENC_TUNING_INFO)encoderParams.tuningInfo);
     FrameRate(fps, initializeParams.frameRateNum, initializeParams.frameRateDen);
@@ -332,8 +343,6 @@ void VideoWriterImpl::CopyToNvSurface(const InputArray src)
             else
                 srcDevice.upload(src);
         }
-        Npp8u* pDst[3] = { dst, &dst[encoderInputFrame->pitch * pEnc->GetEncodeHeight()], &dst[encoderInputFrame->pitch * pEnc->GetEncodeHeight() * 2] };
-        const NppiSize oSizeROI = { pEnc->GetEncodeWidth(), pEnc->GetEncodeHeight() };
         if (surfaceFormatCv == COLOR_FORMAT_CV::BGR) {
             GpuMat dstGpuMat(pEnc->GetEncodeHeight(), pEnc->GetEncodeWidth(), CV_8UC4, dst, encoderInputFrame->pitch);
             cuda::cvtColor(srcDevice, dstGpuMat, COLOR_BGR2BGRA, 0, stream);
@@ -362,7 +371,7 @@ void VideoWriterImpl::CopyToNvSurface(const InputArray src)
     else {
         void* srcPtr = src.isGpuMat() ? src.getGpuMat().data : src.getMat().data;
         const CUmemorytype cuMemoryType = src.isGpuMat() ? CU_MEMORYTYPE_DEVICE : CU_MEMORYTYPE_HOST;
-        NvEncoderCuda::CopyToDeviceFrame(cuContext, srcPtr, src.step(), (CUdeviceptr)encoderInputFrame->inputPtr, (int)encoderInputFrame->pitch, pEnc->GetEncodeWidth(),
+        NvEncoderCuda::CopyToDeviceFrame(cuContext, srcPtr, static_cast<unsigned>(src.step()), (CUdeviceptr)encoderInputFrame->inputPtr, (int)encoderInputFrame->pitch, pEnc->GetEncodeWidth(),
             pEnc->GetEncodeHeight(), cuMemoryType, encoderInputFrame->bufferFormat, encoderInputFrame->chromaOffsets, encoderInputFrame->numChromaPlanes,
             false, cuda::StreamAccessor::getStream(stream));
     }