Alter live source flag everywhere to indicate what it does not what it is for, which should be left up to the documentation.

Author: cudawarped

modules/cudacodec/include/opencv2/cudacodec.hpp

@@ -322,7 +322,7 @@ enum class VideoReaderProps {
     PROP_LRF_HAS_KEY_FRAME = 5, //!< FFmpeg source only - Indicates whether the Last Raw Frame (LRF), output from VideoReader::retrieve() when VideoReader is initialized in raw mode, contains encoded data for a key frame.
     PROP_COLOR_FORMAT = 6, //!< Set the ColorFormat of the decoded frame.  This can be changed before every call to nextFrame() and retrieve().
     PROP_UDP_SOURCE = 7, //!< Status of VideoReaderInitParams::udpSource initialization.
-    PROP_LIVE_SOURCE = 8, //!< Status of VideoReaderInitParams::liveSource initialization.
+    PROP_ALLOW_FRAME_DROP = 8, //!< Status of VideoReaderInitParams::allowFrameDrop initialization.
 #ifndef CV_DOXYGEN
     PROP_NOT_SUPPORTED
 #endif
@@ -472,18 +472,19 @@ class CV_EXPORTS_W RawVideoSource
 
 /** @brief VideoReader initialization parameters
 @param udpSource Remove validation which can cause VideoReader() to throw exceptions when reading from a UDP source.
-@param liveCapture Prevent delay and eventual disconnection from a live capture source when the rate frames are consumed is less than the rate they are captured.
-Use with caution, frames will be dropped when nextFrame()/grab() are called at a slower rate than the source fps.
+@param allowFrameDrop Allow frames to be dropped when ingesting from a live capture source to prevent delay and eventual disconnection
+when calls to nextFrame()/grab() cannot keep up with the source's fps.  Only use if delay and disconnection are a problem, i.e. not when decoding from
+video files where setting this flag will cause frames to be unnecessarily discarded.
 @param minNumDecodeSurfaces Minimum number of internal decode surfaces used by the hardware decoder.  NVDEC will automatically determine the minimum number of
 surfaces it requires for correct functionality and optimal video memory usage but not necessarily for best performance, which depends on the design of the
 overall application. The optimal number of decode surfaces (in terms of performance and memory utilization) should be decided by experimentation for each application,
 but it cannot go below the number determined by NVDEC.
 @param rawMode Allow the raw encoded data which has been read up until the last call to grab() to be retrieved by calling retrieve(rawData,RAW_DATA_IDX).
 */
 struct CV_EXPORTS_W_SIMPLE VideoReaderInitParams {
-    CV_WRAP VideoReaderInitParams() : udpSource(false), liveSource(false), minNumDecodeSurfaces(0), rawMode(0) {};
+    CV_WRAP VideoReaderInitParams() : udpSource(false), allowFrameDrop(false), minNumDecodeSurfaces(0), rawMode(0) {};
     CV_PROP_RW bool udpSource;
-    CV_PROP_RW bool liveSource;
+    CV_PROP_RW bool allowFrameDrop;
     CV_PROP_RW int minNumDecodeSurfaces;
     CV_PROP_RW bool rawMode;
 };

modules/cudacodec/src/video_parser.cpp

@@ -45,8 +45,8 @@
 
 #ifdef HAVE_NVCUVID
 
-cv::cudacodec::detail::VideoParser::VideoParser(VideoDecoder* videoDecoder, FrameQueue* frameQueue, const bool liveSource, const bool udpSource) :
-    videoDecoder_(videoDecoder), frameQueue_(frameQueue), liveSource_(liveSource)
+cv::cudacodec::detail::VideoParser::VideoParser(VideoDecoder* videoDecoder, FrameQueue* frameQueue, const bool allowFrameDrop, const bool udpSource) :
+    videoDecoder_(videoDecoder), frameQueue_(frameQueue), allowFrameDrop_(allowFrameDrop)
 {
     if (udpSource) maxUnparsedPackets_ = 0;
     CUVIDPARSERPARAMS params;
@@ -124,7 +124,7 @@ int CUDAAPI cv::cudacodec::detail::VideoParser::HandleVideoSequence(void* userDa
         newFormat.height = format->coded_height;
         newFormat.displayArea = Rect(Point(format->display_area.left, format->display_area.top), Point(format->display_area.right, format->display_area.bottom));
         newFormat.fps = format->frame_rate.numerator / static_cast<float>(format->frame_rate.denominator);
-        newFormat.ulNumDecodeSurfaces = min(!thiz->liveSource_ ? max(thiz->videoDecoder_->nDecodeSurfaces(), static_cast<int>(format->min_num_decode_surfaces)) :
+        newFormat.ulNumDecodeSurfaces = min(!thiz->allowFrameDrop_ ? max(thiz->videoDecoder_->nDecodeSurfaces(), static_cast<int>(format->min_num_decode_surfaces)) :
             format->min_num_decode_surfaces * 2, 32);
         if (format->progressive_sequence)
             newFormat.deinterlaceMode = Weave;
@@ -167,7 +167,7 @@ int CUDAAPI cv::cudacodec::detail::VideoParser::HandlePictureDecode(void* userDa
 
     thiz->unparsedPackets_ = 0;
 
-    bool isFrameAvailable = thiz->frameQueue_->waitUntilFrameAvailable(picParams->CurrPicIdx, thiz->liveSource_);
+    bool isFrameAvailable = thiz->frameQueue_->waitUntilFrameAvailable(picParams->CurrPicIdx, thiz->allowFrameDrop_);
     if (!isFrameAvailable)
         return false;
 

modules/cudacodec/src/video_parser.hpp

@@ -52,7 +52,7 @@ namespace cv { namespace cudacodec { namespace detail {
 class VideoParser
 {
 public:
-    VideoParser(VideoDecoder* videoDecoder, FrameQueue* frameQueue, const bool liveSource = false, const bool udpSource = false);
+    VideoParser(VideoDecoder* videoDecoder, FrameQueue* frameQueue, const bool allowFrameDrop = false, const bool udpSource = false);
 
     ~VideoParser()
     {
@@ -65,7 +65,7 @@ class VideoParser
 
     bool udpSource() const { return  maxUnparsedPackets_ == 0; }
 
-    bool liveStream() const { return liveSource_; }
+    bool allowFrameDrops() const { return allowFrameDrop_; }
 
 private:
     VideoDecoder* videoDecoder_ = 0;
@@ -75,7 +75,7 @@ class VideoParser
     int maxUnparsedPackets_ = 20;
     std::vector<RawPacket> currentFramePackets;
     volatile bool hasError_ = false;
-    bool liveSource_ = false;
+    bool allowFrameDrop_ = false;
 
     // Called when the decoder encounters a video format change (or initial sequence header)
     // This particular implementation of the callback returns 0 in case the video format changes

modules/cudacodec/src/video_reader.cpp

@@ -86,7 +86,7 @@ namespace
     class VideoReaderImpl : public VideoReader
     {
     public:
-        explicit VideoReaderImpl(const Ptr<VideoSource>& source, const int minNumDecodeSurfaces, const bool liveSource = false , const bool udpSource = false);
+        explicit VideoReaderImpl(const Ptr<VideoSource>& source, const int minNumDecodeSurfaces, const bool allowFrameDrop = false , const bool udpSource = false);
         ~VideoReaderImpl();
 
         bool nextFrame(GpuMat& frame, Stream& stream) CV_OVERRIDE;
@@ -130,7 +130,7 @@ namespace
         return videoSource_->format();
     }
 
-    VideoReaderImpl::VideoReaderImpl(const Ptr<VideoSource>& source, const int minNumDecodeSurfaces, const bool liveSource, const bool udpSource) :
+    VideoReaderImpl::VideoReaderImpl(const Ptr<VideoSource>& source, const int minNumDecodeSurfaces, const bool allowFrameDrop, const bool udpSource) :
         videoSource_(source),
         lock_(0)
     {
@@ -143,7 +143,7 @@ namespace
         cuSafeCall( cuvidCtxLockCreate(&lock_, ctx) );
         frameQueue_.reset(new FrameQueue());
         videoDecoder_.reset(new VideoDecoder(videoSource_->format().codec, minNumDecodeSurfaces, ctx, lock_));
-        videoParser_.reset(new VideoParser(videoDecoder_, frameQueue_, liveSource, udpSource));
+        videoParser_.reset(new VideoParser(videoDecoder_, frameQueue_, allowFrameDrop, udpSource));
         videoSource_->setVideoParser(videoParser_);
         videoSource_->start();
     }
@@ -303,8 +303,8 @@ namespace
             else
                 break;
         }
-        case VideoReaderProps::PROP_LIVE_SOURCE: {
-            propertyVal = videoParser_->liveStream();
+        case VideoReaderProps::PROP_ALLOW_FRAME_DROP: {
+            propertyVal = videoParser_->allowFrameDrops();
             return true;
         }
         case VideoReaderProps::PROP_UDP_SOURCE: {
@@ -347,7 +347,7 @@ Ptr<VideoReader> cv::cudacodec::createVideoReader(const String& filename, const
         videoSource.reset(new CuvidVideoSource(filename));
     }
 
-    return makePtr<VideoReaderImpl>(videoSource, params.minNumDecodeSurfaces, params.liveSource, params.udpSource);
+    return makePtr<VideoReaderImpl>(videoSource, params.minNumDecodeSurfaces, params.allowFrameDrop, params.udpSource);
 }
 
 Ptr<VideoReader> cv::cudacodec::createVideoReader(const Ptr<RawVideoSource>& source, const VideoReaderInitParams params)

modules/cudacodec/test/test_video.cpp

@@ -360,12 +360,12 @@ CUDA_TEST_P(CheckInitParams, Reader)
     const std::string inputFile = std::string(cvtest::TS::ptr()->get_data_path()) + "../" + GET_PARAM(1);
     cv::cudacodec::VideoReaderInitParams params;
     params.udpSource = GET_PARAM(2);
-    params.liveSource = GET_PARAM(3);
+    params.allowFrameDrop = GET_PARAM(3);
     params.rawMode = GET_PARAM(4);
-    double udpSource = 0, liveSource = 0, rawMode = 0;
+    double udpSource = 0, allowFrameDrop = 0, rawMode = 0;
     cv::Ptr<cv::cudacodec::VideoReader> reader = cv::cudacodec::createVideoReader(inputFile, {}, params);
     ASSERT_TRUE(reader->get(cv::cudacodec::VideoReaderProps::PROP_UDP_SOURCE, udpSource) && static_cast<bool>(udpSource) == params.udpSource);
-    ASSERT_TRUE(reader->get(cv::cudacodec::VideoReaderProps::PROP_LIVE_SOURCE, liveSource) && static_cast<bool>(liveSource) == params.liveSource);
+    ASSERT_TRUE(reader->get(cv::cudacodec::VideoReaderProps::PROP_ALLOW_FRAME_DROP, allowFrameDrop) && static_cast<bool>(allowFrameDrop) == params.allowFrameDrop);
     ASSERT_TRUE(reader->get(cv::cudacodec::VideoReaderProps::PROP_RAW_MODE, rawMode) && static_cast<bool>(rawMode) == params.rawMode);
 }