Extend Codec and ColorFormat enums instead of using VideoWriter specific ones and use camel-case for enum names.

Author: cudawarped

modules/cudacodec/include/opencv2/cudacodec.hpp

@@ -66,43 +66,64 @@ using namespace cuda;  // Stream
 
 ////////////////////////////////// Video Encoding //////////////////////////////////
 
-/** @brief Codecs supported by Video writer, refer to Nvidia's GPU Support Matrix to confirm your GPU supports them.
-*/
-enum class CODEC_VW
+/** @brief Video codecs supported by cudacodec::VideoReader and cudacodec::VideoWriter.
+@note
+   -   Support will depend on your hardware, refer to the Nvidia Video Codec SDK Video Encode and Decode GPU Support Matrix for details.
+ */
+enum Codec
 {
-    H264 = 0,
-    HEVC = 1,
-    NumCodecs = 2
+    MPEG1 = 0,
+    MPEG2,
+    MPEG4,
+    VC1,
+    H264,
+    JPEG,
+    H264_SVC,
+    H264_MVC,
+    HEVC,
+    VP8,
+    VP9,
+    AV1,
+    NumCodecs,
+
+    Uncompressed_YUV420 = (('I' << 24) | ('Y' << 16) | ('U' << 8) | ('V')),   //!< Y,U,V (4:2:0)
+    Uncompressed_YV12 = (('Y' << 24) | ('V' << 16) | ('1' << 8) | ('2')),   //!< Y,V,U (4:2:0)
+    Uncompressed_NV12 = (('N' << 24) | ('V' << 16) | ('1' << 8) | ('2')),   //!< Y,UV  (4:2:0)
+    Uncompressed_YUYV = (('Y' << 24) | ('U' << 16) | ('Y' << 8) | ('V')),   //!< YUYV/YUY2 (4:2:2)
+    Uncompressed_UYVY = (('U' << 24) | ('Y' << 16) | ('V' << 8) | ('Y'))    //!< UYVY (4:2:2)
 };
 
-/** @brief Video writer color formats.
+/** @brief ColorFormat for the frame returned by VideoReader::nextFrame()/VideoReader::retrieve() or used to initialize a VideoWriter.
 */
-enum COLOR_FORMAT_VW {
+enum class ColorFormat {
     UNDEFINED = 0,
-    BGR = 1, //!< Default OpenCV color format.
-    RGB = 2,
-    BGRA = 3,
-    RGBA = 4,
-    GRAY = 5,
-
-    NV_NV12 = 6, //!< Nvidia Buffer Format - Semi-Planar YUV [Y plane followed by interleaved UV plane].
-    NV_YV12 = 7, //!< Nvidia Buffer Format - Planar YUV [Y plane followed by V and U planes].
-    NV_IYUV = 8, //!< Nvidia Buffer Format - Planar YUV [Y plane followed by U and V planes].
-    NV_YUV444 = 9, //!< Nvidia Buffer Format - Planar YUV [Y plane followed by U and V planes].
-    NV_AYUV = 10 //!< Nvidia Buffer Format - 8 bit Packed A8Y8U8V8. This is a word-ordered format where a pixel is represented by a 32-bit word with V in the lowest 8 bits, U in the next 8 bits, Y in the 8 bits after that and A in the highest 8 bits.
+    BGRA = 1, //!< OpenCV color format, can be used with both VideoReader and VideoWriter.
+    BGR = 2, //!< OpenCV color format, can be used with both VideoReader and VideoWriter.
+    GRAY = 3, //!< OpenCV color format, can be used with both VideoReader and VideoWriter.
+    NV_NV12 = 4, //!< Nvidia color format - equivalent to YUV - Semi-Planar YUV [Y plane followed by interleaved UV plane], can be used with both VideoReader and VideoWriter.
+
+    RGB = 5, //!< OpenCV color format, can only be used with VideoWriter.
+    RGBA = 6, //!< OpenCV color format, can only be used with VideoWriter.
+    NV_YV12 = 8, //!< Nvidia Buffer Format - Planar YUV [Y plane followed by V and U planes], use with VideoReader, can only be used with VideoWriter.
+    NV_IYUV = 9, //!< Nvidia Buffer Format - Planar YUV [Y plane followed by U and V planes], use with VideoReader, can only be used with VideoWriter.
+    NV_YUV444 = 10, //!< Nvidia Buffer Format - Planar YUV [Y plane followed by U and V planes], use with VideoReader, can only be used with VideoWriter.
+    NV_AYUV = 11, //!< Nvidia Buffer Format - 8 bit Packed A8Y8U8V8. This is a word-ordered format where a pixel is represented by a 32-bit word with V in the lowest 8 bits, U in the next 8 bits, Y in the 8 bits after that and A in the highest 8 bits, can only be used with VideoWriter.
+#ifndef CV_DOXYGEN
+    PROP_NOT_SUPPORTED
+#endif
 };
 
 /** @brief Rate Control Modes.
 */
-enum ENC_PARAMS_RC_MODE {
+enum EncodeParamsRcMode {
     ENC_PARAMS_RC_CONSTQP = 0x0, //!< Constant QP mode.
     ENC_PARAMS_RC_VBR = 0x1, //!< Variable bitrate mode.
     ENC_PARAMS_RC_CBR = 0x2 //!< Constant bitrate mode.
 };
 
 /** @brief Multi Pass Encoding.
 */
-enum ENC_MULTI_PASS
+enum EncodeMultiPass
 {
     ENC_MULTI_PASS_DISABLED = 0x0, //!< Single Pass.
     ENC_TWO_PASS_QUARTER_RESOLUTION = 0x1, //!< Two Pass encoding is enabled where first Pass is quarter resolution.
@@ -112,7 +133,7 @@ enum ENC_MULTI_PASS
 
 /** @brief Supported Encoder Profiles.
 */
-enum ENC_PROFILE {
+enum EncodeProfile {
     ENC_CODEC_PROFILE_AUTOSELECT = 0,
     ENC_H264_PROFILE_BASELINE = 1,
     ENC_H264_PROFILE_MAIN = 2,
@@ -128,7 +149,7 @@ enum ENC_PROFILE {
 
 /** @brief Nvidia Encoding Presets. Performance degrades and quality improves as we move from P1 to P7.
 */
-enum ENC_PRESET {
+enum EncodePreset {
     ENC_PRESET_P1 = 1,
     ENC_PRESET_P2 = 2,
     ENC_PRESET_P3 = 3,
@@ -140,7 +161,7 @@ enum ENC_PRESET {
 
 /** @brief Tuning information.
 */
-enum ENC_TUNING_INFO {
+enum EncodeTuningInfo {
     ENC_TUNING_INFO_UNDEFINED = 0, //!< Undefined tuningInfo. Invalid value for encoding.
     ENC_TUNING_INFO_HIGH_QUALITY = 1, //!< Tune presets for latency tolerant encoding.
     ENC_TUNING_INFO_LOW_LATENCY = 2, //!< Tune presets for low latency streaming.
@@ -151,7 +172,7 @@ enum ENC_TUNING_INFO {
 
 /** Quantization Parameter for each type of frame when using ENC_PARAMS_RC_MODE::ENC_PARAMS_RC_CONSTQP.
 */
-struct CV_EXPORTS_W_SIMPLE ENC_QP
+struct CV_EXPORTS_W_SIMPLE EncodeQp
 {
     CV_PROP_RW uint32_t qpInterP; //!< Specifies QP value for P-frame.
     CV_PROP_RW uint32_t qpInterB; //!< Specifies QP value for B-frame.
@@ -164,12 +185,12 @@ struct CV_EXPORTS_W_SIMPLE EncoderParams
 {
 public:
     CV_WRAP EncoderParams();
-    CV_PROP_RW ENC_PRESET nvPreset;
-    CV_PROP_RW ENC_TUNING_INFO tuningInfo;
-    CV_PROP_RW ENC_PROFILE encodingProfile;
-    CV_PROP_RW ENC_PARAMS_RC_MODE rateControlMode;
-    CV_PROP_RW ENC_MULTI_PASS multiPassEncoding;
-    CV_PROP_RW ENC_QP constQp; //!< QP's for ENC_PARAMS_RC_CONSTQP.
+    CV_PROP_RW EncodePreset nvPreset;
+    CV_PROP_RW EncodeTuningInfo tuningInfo;
+    CV_PROP_RW EncodeProfile encodingProfile;
+    CV_PROP_RW EncodeParamsRcMode rateControlMode;
+    CV_PROP_RW EncodeMultiPass multiPassEncoding;
+    CV_PROP_RW EncodeQp 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 uint8_t targetQuality; //!< value 0 - 51 where video quality decreases as targetQuality increases, used with ENC_PARAMS_RC_VBR.
@@ -234,8 +255,8 @@ class CV_EXPORTS_W VideoWriter
 @param encoderCallback Callbacks for video encoder. See cudacodec::EncoderCallback. Required for working with the encoded video stream.
 @param stream Stream for frame pre-processing.
 */
-CV_EXPORTS_W Ptr<cudacodec::VideoWriter> createVideoWriter(const String& fileName, const Size frameSize, const CODEC_VW codec = CODEC_VW::H264, const double fps = 25.0,
-    const COLOR_FORMAT_VW colorFormat = BGR, Ptr<EncoderCallback> encoderCallback = 0, const Stream& stream = Stream::Null());
+CV_EXPORTS_W Ptr<cudacodec::VideoWriter> createVideoWriter(const String& fileName, const Size frameSize, const Codec codec = Codec::H264, const double fps = 25.0,
+    const ColorFormat colorFormat = ColorFormat::BGR, Ptr<EncoderCallback> encoderCallback = 0, const Stream& stream = Stream::Null());
 
 /** @brief Creates video writer.
 
@@ -248,36 +269,11 @@ CV_EXPORTS_W Ptr<cudacodec::VideoWriter> createVideoWriter(const String& fileNam
 @param encoderCallback Callbacks for video encoder. See cudacodec::EncoderCallback. Required for working with the encoded video stream.
 @param stream Stream for frame pre-processing.
 */
-CV_EXPORTS_W Ptr<cudacodec::VideoWriter> createVideoWriter(const String& fileName, const Size frameSize, const CODEC_VW codec, const double fps,  const COLOR_FORMAT_VW colorFormat,
+CV_EXPORTS_W Ptr<cudacodec::VideoWriter> createVideoWriter(const String& fileName, const Size frameSize, const Codec codec, const double fps,  const ColorFormat colorFormat,
     const EncoderParams& params, Ptr<EncoderCallback> encoderCallback = 0, const Stream& stream = Stream::Null());
 
 ////////////////////////////////// Video Decoding //////////////////////////////////////////
 
-/** @brief Video codecs supported by cudacodec::VideoReader.
- */
-enum Codec
-{
-    MPEG1 = 0,
-    MPEG2,
-    MPEG4,
-    VC1,
-    H264,
-    JPEG,
-    H264_SVC,
-    H264_MVC,
-    HEVC,
-    VP8,
-    VP9,
-    AV1,
-    NumCodecs,
-
-    Uncompressed_YUV420 = (('I'<<24)|('Y'<<16)|('U'<<8)|('V')),   //!< Y,U,V (4:2:0)
-    Uncompressed_YV12   = (('Y'<<24)|('V'<<16)|('1'<<8)|('2')),   //!< Y,V,U (4:2:0)
-    Uncompressed_NV12   = (('N'<<24)|('V'<<16)|('1'<<8)|('2')),   //!< Y,UV  (4:2:0)
-    Uncompressed_YUYV   = (('Y'<<24)|('U'<<16)|('Y'<<8)|('V')),   //!< YUYV/YUY2 (4:2:2)
-    Uncompressed_UYVY   = (('U'<<24)|('Y'<<16)|('V'<<8)|('Y'))    //!< UYVY (4:2:2)
-};
-
 /** @brief Chroma formats supported by cudacodec::VideoReader.
  */
 enum ChromaFormat
@@ -344,18 +340,6 @@ enum class VideoReaderProps {
 #endif
 };
 
-/** @brief ColorFormat for the frame returned by nextFrame()/retrieve().
-*/
-enum class ColorFormat {
-    BGRA = 1,
-    BGR = 2,
-    GRAY = 3,
-    YUV = 4,
-#ifndef CV_DOXYGEN
-    PROP_NOT_SUPPORTED
-#endif
-};
-
 /** @brief Video reader interface.
 
 @note
@@ -451,8 +435,9 @@ class CV_EXPORTS_W VideoReader
     /** @brief Set the desired ColorFormat for the frame returned by nextFrame()/retrieve().
 
     @param colorFormat Value of the ColorFormat.
+    @return `true` unless the colorFormat is not supported.
      */
-    CV_WRAP virtual void set(const ColorFormat colorFormat) = 0;
+    CV_WRAP virtual bool set(const ColorFormat colorFormat) = 0;
 
     /** @brief Returns the specified VideoReader property
 

modules/cudacodec/misc/python/test/test_cudacodec.py

@@ -85,11 +85,11 @@ def test_writer_existence(self):
             encoder_params_in.gopLength = 10
             stream = cv.cuda.Stream()
             sz = (1920,1080)
-            writer = cv.cudacodec.createVideoWriter(fname, sz, cv.cudacodec.VideoWriterCodec_H264, 30, cv.cudacodec.ColorFormat_BGR,
-                                                    encoder_params_in, stream)
+            writer = cv.cudacodec.createVideoWriter(fname, sz, cv.cudacodec.H264, 30, cv.cudacodec.ColorFormat_BGR,
+                                                    encoder_params_in, stream=stream)
             blankFrameIn = cv.cuda.GpuMat(sz,cv.CV_8UC3)
             writer.write(blankFrameIn)
-            writer.close()
+            writer.release()
             encoder_params_out = writer.getEncoderParams()
             self.assert_true(encoder_params_in.gopLength == encoder_params_out.gopLength)
             cap = cv.VideoCapture(fname,cv.CAP_FFMPEG)

modules/cudacodec/perf/perf_video.cpp

@@ -97,41 +97,41 @@ PERF_TEST_P(FileName, VideoReader, VIDEO_SRC)
 
 #if defined(HAVE_NVCUVENC)
 
-DEF_PARAM_TEST(WriteToFile, string, cv::cudacodec::COLOR_FORMAT_VW, cv::cudacodec::CODEC_VW);
+DEF_PARAM_TEST(WriteToFile, string, cv::cudacodec::ColorFormat, cv::cudacodec::Codec);
 
-#define COLOR_FORMAT Values(cv::cudacodec::COLOR_FORMAT_VW::BGR, cv::cudacodec::COLOR_FORMAT_VW::RGB, cv::cudacodec::COLOR_FORMAT_VW::BGRA, \
-cv::cudacodec::COLOR_FORMAT_VW::RGBA, cv::cudacodec::COLOR_FORMAT_VW::GRAY)
-#define CODEC Values(cv::cudacodec::CODEC_VW::H264, cv::cudacodec::CODEC_VW::HEVC)
+#define COLOR_FORMAT Values(cv::cudacodec::ColorFormat::BGR, cv::cudacodec::ColorFormat::RGB, cv::cudacodec::ColorFormat::BGRA, \
+cv::cudacodec::ColorFormat::RGBA, cv::cudacodec::ColorFormat::GRAY)
+#define CODEC Values(cv::cudacodec::Codec::H264, cv::cudacodec::Codec::HEVC)
 
 PERF_TEST_P(WriteToFile, VideoWriter, Combine(VIDEO_SRC, COLOR_FORMAT, CODEC))
 {
     declare.time(30);
     const string inputFile = perf::TestBase::getDataPath(GET_PARAM(0));
-    const cv::cudacodec::COLOR_FORMAT_VW surfaceFormat = GET_PARAM(1);
-    const cudacodec::CODEC_VW codec = GET_PARAM(2);
+    const cv::cudacodec::ColorFormat surfaceFormat = GET_PARAM(1);
+    const cudacodec::Codec codec = GET_PARAM(2);
     const double fps = 25;
     const int nFrames = 20;
     cv::VideoCapture reader(inputFile);
     ASSERT_TRUE(reader.isOpened());
     Mat frameBgr;
     if (PERF_RUN_CUDA()) {
-        const std::string ext = codec == cudacodec::CODEC_VW::H264 ? ".h264" : ".hevc";
+        const std::string ext = codec == cudacodec::Codec::H264 ? ".h264" : ".hevc";
         const string outputFile = cv::tempfile(ext.c_str());
         std::vector<GpuMat> frames;
         cv::Mat frameNewSf;
         cuda::Stream stream;
         ColorConversionCodes conversionCode = COLOR_COLORCVT_MAX;
         switch (surfaceFormat) {
-        case cudacodec::COLOR_FORMAT_VW::RGB:
+        case cudacodec::ColorFormat::RGB:
             conversionCode = COLOR_BGR2RGB;
             break;
-        case cudacodec::COLOR_FORMAT_VW::BGRA:
+        case cudacodec::ColorFormat::BGRA:
             conversionCode = COLOR_BGR2BGRA;
             break;
-        case cudacodec::COLOR_FORMAT_VW::RGBA:
+        case cudacodec::ColorFormat::RGBA:
             conversionCode = COLOR_BGR2RGBA;
             break;
-        case cudacodec::COLOR_FORMAT_VW::GRAY:
+        case cudacodec::ColorFormat::GRAY:
             conversionCode = COLOR_BGR2GRAY;
         default:
             break;
@@ -161,7 +161,7 @@ PERF_TEST_P(WriteToFile, VideoWriter, Combine(VIDEO_SRC, COLOR_FORMAT, CODEC))
         ASSERT_EQ(0, remove(outputFile.c_str()));
     }
     else {
-        if (surfaceFormat != cv::cudacodec::COLOR_FORMAT_VW::BGR || codec != cv::cudacodec::CODEC_VW::H264)
+        if (surfaceFormat != cv::cudacodec::ColorFormat::BGR || codec != cv::cudacodec::Codec::H264)
             throw PerfSkipTestException();
         cv::VideoWriter writer;
         const string outputFile = cv::tempfile(".avi");

modules/cudacodec/src/video_reader.cpp

@@ -54,6 +54,7 @@ Ptr<VideoReader> cv::cudacodec::createVideoReader(const Ptr<RawVideoSource>&, co
 #else // HAVE_NVCUVID
 
 void nv12ToBgra(const GpuMat& decodedFrame, GpuMat& outFrame, int width, int height, cudaStream_t stream);
+bool ValidColorFormat(const ColorFormat colorFormat);
 
 void videoDecPostProcessFrame(const GpuMat& decodedFrame, GpuMat& outFrame, int width, int height, const ColorFormat colorFormat,
     Stream stream)
@@ -74,7 +75,7 @@ void videoDecPostProcessFrame(const GpuMat& decodedFrame, GpuMat& outFrame, int
         outFrame.create(height, width, CV_8UC1);
         cudaMemcpy2DAsync(outFrame.ptr(), outFrame.step, decodedFrame.ptr(), decodedFrame.step, width, height, cudaMemcpyDeviceToDevice, StreamAccessor::getStream(stream));
     }
-    else if (colorFormat == ColorFormat::YUV) {
+    else if (colorFormat == ColorFormat::NV_NV12) {
         decodedFrame.copyTo(outFrame, stream);
     }
 }
@@ -100,7 +101,7 @@ namespace
 
         bool set(const VideoReaderProps propertyId, const double propertyVal) CV_OVERRIDE;
 
-        void set(const ColorFormat _colorFormat) CV_OVERRIDE;
+        bool set(const ColorFormat colorFormat_) CV_OVERRIDE;
 
         bool get(const VideoReaderProps propertyId, double& propertyVal) const CV_OVERRIDE;
         bool getVideoReaderProps(const VideoReaderProps propertyId, double& propertyValOut, double propertyValIn) const CV_OVERRIDE;
@@ -273,8 +274,16 @@ namespace
         return false;
     }
 
-    void VideoReaderImpl::set(const ColorFormat _colorFormat) {
-        colorFormat = _colorFormat;
+    bool ValidColorFormat(const ColorFormat colorFormat) {
+        if (colorFormat == ColorFormat::BGRA || colorFormat == ColorFormat::BGR || colorFormat == ColorFormat::GRAY || colorFormat == ColorFormat::NV_NV12)
+            return true;
+        return false;
+    }
+
+    bool VideoReaderImpl::set(const ColorFormat colorFormat_) {
+        if (!ValidColorFormat(colorFormat_)) return false;
+        colorFormat = colorFormat_;
+        return true;
     }
 
     bool VideoReaderImpl::get(const VideoReaderProps propertyId, double& propertyVal) const {