Remove VideoReader::grab()

Author: cudawarped

modules/cudacodec/include/opencv2/cudacodec.hpp

@@ -336,7 +336,6 @@ struct CV_EXPORTS_W_SIMPLE FormatInfo
 /** @brief cv::cudacodec::VideoReader generic properties identifier.
 */
 enum class VideoReaderProps {
-    PROP_DECODED_FRAME_IDX = 0, //!< Index for retrieving the decoded frame using retrieve().
     PROP_EXTRA_DATA_INDEX = 1, //!< Index for retrieving the extra data associated with a video source using retrieve().
     PROP_RAW_PACKAGES_BASE_INDEX = 2, //!< Base index for retrieving raw encoded data using retrieve().
     PROP_NUMBER_OF_RAW_PACKAGES_SINCE_LAST_GRAB = 3, //!< Number of raw packages recieved since the last call to grab().
@@ -379,36 +378,9 @@ class CV_EXPORTS_W VideoReader
     */
     CV_WRAP virtual FormatInfo format() const = 0;
 
-    /** @brief Grabs the next frame from the video source.
-
-    @param stream Stream for the asynchronous version.
-    @return `true` (non-zero) in the case of success.
-
-    The method/function grabs the next frame from video file or camera and returns true (non-zero) in
-    the case of success.
-
-    The primary use of the function is for reading both the encoded and decoded video data when rawMode is enabled.  With rawMode enabled
-    retrieve() can be called following grab() to retrieve all the data associated with the current video source since the last call to grab() or the creation of the VideoReader.
-     */
-    CV_WRAP virtual bool grab(Stream& stream = Stream::Null()) = 0;
-
     /** @brief Returns previously grabbed video data.
 
     @param [out] frame The returned data which depends on the provided idx.
-    @param idx Determines the returned data inside image. The returned data can be the:
-     - Decoded frame, idx = get(PROP_DECODED_FRAME_IDX).
-     - Extra data if available, idx = get(PROP_EXTRA_DATA_INDEX).
-     - Raw encoded data package.  To retrieve package i,  idx = get(PROP_RAW_PACKAGES_BASE_INDEX) + i with i < get(PROP_NUMBER_OF_RAW_PACKAGES_SINCE_LAST_GRAB)
-    @return `false` if no frames have been grabbed
-
-    The method returns data associated with the current video source since the last call to grab() or the creation of the VideoReader. If no data is present
-    the method returns false and the function returns an empty image.
-     */
-    virtual bool retrieve(OutputArray frame, const size_t idx = static_cast<size_t>(VideoReaderProps::PROP_DECODED_FRAME_IDX)) const = 0;
-
-    /** @brief Returns previously grabbed encoded video data.
-
-    @param [out] frame The encoded video data.
     @param idx Determines the returned data inside image. The returned data can be the:
      - Extra data if available, idx = get(PROP_EXTRA_DATA_INDEX).
      - Raw encoded data package.  To retrieve package i,  idx = get(PROP_RAW_PACKAGES_BASE_INDEX) + i with i < get(PROP_NUMBER_OF_RAW_PACKAGES_SINCE_LAST_GRAB)
@@ -417,21 +389,7 @@ class CV_EXPORTS_W VideoReader
     The method returns data associated with the current video source since the last call to grab() or the creation of the VideoReader. If no data is present
     the method returns false and the function returns an empty image.
      */
-    CV_WRAP inline bool retrieve(CV_OUT Mat& frame, const size_t idx) const {
-        return retrieve(OutputArray(frame), idx);
-    }
-
-    /** @brief Returns the next video frame.
-
-    @param [out] frame The video frame.  If grab() has not been called then this will be empty().
-    @return `false` if no frames have been grabbed
-
-    The method returns data associated with the current video source since the last call to grab(). If no data is present
-    the method returns false and the function returns an empty image.
-     */
-    CV_WRAP inline bool retrieve(CV_OUT GpuMat& frame) const {
-        return retrieve(OutputArray(frame));
-    }
+    CV_WRAP virtual bool retrieve(OutputArray frame, const size_t idx) const = 0;
 
     /** @brief Sets a property in the VideoReader.
 

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

@@ -55,8 +55,6 @@ def test_reader(self):
             self.assertTrue(ret and i_base == 2.0)
             ret, gpu_mat3 = reader.nextFrame()
             self.assertTrue(ret and isinstance(gpu_mat3,cv.cuda.GpuMat) and not gpu_mat3.empty())
-            ret = reader.retrieve(gpu_mat3)
-            self.assertTrue(ret and isinstance(gpu_mat3,cv.cuda.GpuMat) and not gpu_mat3.empty())
             ret, n_raw_packages_since_last_grab = reader.getVideoReaderProps(cv.cudacodec.VideoReaderProps_PROP_NUMBER_OF_RAW_PACKAGES_SINCE_LAST_GRAB)
             self.assertTrue(ret and n_raw_packages_since_last_grab > 0)
             self.assertTrue(reader.rawPackageHasKeyFrame(int(i_base)))

modules/cudacodec/src/video_reader.cpp

@@ -121,8 +121,6 @@ namespace
 
         FormatInfo format() const CV_OVERRIDE;
 
-        bool grab(Stream& stream) CV_OVERRIDE;
-
         bool retrieve(OutputArray frame, const size_t idx) const CV_OVERRIDE;
 
         bool set(const VideoReaderProps propertyId, const double propertyVal) CV_OVERRIDE;
@@ -136,7 +134,6 @@ namespace
         bool rawPackageHasKeyFrame(const int idx) const CV_OVERRIDE;
 
     private:
-        bool internalGrab(GpuMat& frame, Stream& stream);
         void waitForDecoderInit();
 
         Ptr<VideoSource> videoSource_;
@@ -207,7 +204,7 @@ namespace
         CUvideoctxlock m_lock;
     };
 
-    bool VideoReaderImpl::internalGrab(GpuMat& frame, Stream& stream) {
+    bool VideoReaderImpl::nextFrame(GpuMat& frame, Stream& stream) {
         if (videoParser_->hasError())
             CV_Error(Error::StsError, "Parsing/Decoding video source failed, check GPU memory is available and GPU supports hardware decoding.");
 
@@ -275,17 +272,8 @@ namespace
         return true;
     }
 
-    bool VideoReaderImpl::grab(Stream& stream) {
-        return internalGrab(lastFrame, stream);
-    }
-
     bool VideoReaderImpl::retrieve(OutputArray frame, const size_t idx) const {
-        if (idx == decodedFrameIdx) {
-            if (!frame.isGpuMat())
-                CV_Error(Error::StsUnsupportedFormat, "Decoded frame is stored on the device and must be retrieved using a cv::cuda::GpuMat");
-            frame.getGpuMatRef() = lastFrame;
-        }
-        else if (idx == extraDataIdx) {
+        if (idx == extraDataIdx) {
             if (!frame.isMat())
                 CV_Error(Error::StsUnsupportedFormat, "Extra data  is stored on the host and must be retrieved using a cv::Mat");
             videoSource_->getExtraData(frame.getMatRef());
@@ -338,9 +326,6 @@ namespace
     bool VideoReaderImpl::get(const VideoReaderProps propertyId, double& propertyVal) const {
         switch (propertyId)
         {
-        case VideoReaderProps::PROP_DECODED_FRAME_IDX:
-            propertyVal =  decodedFrameIdx;
-            return true;
         case VideoReaderProps::PROP_EXTRA_DATA_INDEX:
             propertyVal = extraDataIdx;
             return true;
@@ -383,13 +368,6 @@ namespace
     bool VideoReaderImpl::get(const int propertyId, double& propertyVal) const {
         return videoSource_->get(propertyId, propertyVal);
     }
-
-    bool VideoReaderImpl::nextFrame(GpuMat& frame, Stream& stream)
-    {
-        if (!internalGrab(frame, stream))
-            return false;
-        return true;
-    }
 }
 
 Ptr<VideoReader> cv::cudacodec::createVideoReader(const String& filename, const std::vector<int>& sourceParams, const VideoReaderInitParams params)

modules/cudacodec/test/test_video.cpp

@@ -132,7 +132,8 @@ CUDA_TEST_P(CheckSet, Reader)
     ASSERT_TRUE(reader->get(cv::cudacodec::VideoReaderProps::PROP_RAW_MODE, rawModeVal));
     ASSERT_TRUE(rawModeVal);
     bool rawPacketsAvailable = false;
-    while (reader->grab()) {
+    GpuMat frame;
+    while (reader->nextFrame(frame)) {
         double nRawPackages = -1;
         ASSERT_TRUE(reader->get(cv::cudacodec::VideoReaderProps::PROP_NUMBER_OF_RAW_PACKAGES_SINCE_LAST_GRAB, nRawPackages));
         if (nRawPackages > 0) {
@@ -159,7 +160,8 @@ CUDA_TEST_P(CheckExtraData, Reader)
     double extraDataIdx = -1;
     ASSERT_TRUE(reader->get(cv::cudacodec::VideoReaderProps::PROP_EXTRA_DATA_INDEX, extraDataIdx));
     ASSERT_EQ(extraDataIdx, 1 );
-    ASSERT_TRUE(reader->grab());
+    GpuMat frame;
+    ASSERT_TRUE(reader->nextFrame(frame));
     cv::Mat extraData;
     const bool newData = reader->retrieve(extraData, static_cast<size_t>(extraDataIdx));
     ASSERT_TRUE((newData && sz) || (!newData && !sz));
@@ -184,8 +186,9 @@ CUDA_TEST_P(CheckKeyFrame, Reader)
     ASSERT_EQ(rawIdxBase, 2);
     constexpr int maxNPackagesToCheck = 2;
     int nPackages = 0;
+    GpuMat frame;
     while (nPackages < maxNPackagesToCheck) {
-        ASSERT_TRUE(reader->grab());
+        ASSERT_TRUE(reader->nextFrame(frame));
         double N = -1;
         ASSERT_TRUE(reader->get(cv::cudacodec::VideoReaderProps::PROP_NUMBER_OF_RAW_PACKAGES_SINCE_LAST_GRAB,N));
         for (int i = static_cast<int>(rawIdxBase); i < static_cast<int>(N + rawIdxBase); i++) {
@@ -438,8 +441,7 @@ CUDA_TEST_P(VideoReadRaw, Reader)
         cv::cuda::GpuMat frame;
         for (int i = 0; i < 100; i++)
         {
-            ASSERT_TRUE(reader->grab());
-            ASSERT_TRUE(reader->retrieve(frame));
+            ASSERT_TRUE(reader->nextFrame(frame));
             ASSERT_FALSE(frame.empty());
             double N = -1;
             ASSERT_TRUE(reader->get(cv::cudacodec::VideoReaderProps::PROP_NUMBER_OF_RAW_PACKAGES_SINCE_LAST_GRAB,N));
@@ -459,16 +461,12 @@ CUDA_TEST_P(VideoReadRaw, Reader)
         cv::cudacodec::VideoReaderInitParams params;
         params.rawMode = true;
         cv::Ptr<cv::cudacodec::VideoReader> readerActual = cv::cudacodec::createVideoReader(fileNameOut, {}, params);
-        double decodedFrameIdx = -1;
-        ASSERT_TRUE(readerActual->get(cv::cudacodec::VideoReaderProps::PROP_DECODED_FRAME_IDX, decodedFrameIdx));
-        ASSERT_EQ(decodedFrameIdx, 0);
         cv::cuda::GpuMat reference, actual;
         cv::Mat referenceHost, actualHost;
         for (int i = 0; i < 100; i++)
         {
             ASSERT_TRUE(readerReference->nextFrame(reference));
-            ASSERT_TRUE(readerActual->grab());
-            ASSERT_TRUE(readerActual->retrieve(actual, static_cast<size_t>(decodedFrameIdx)));
+            ASSERT_TRUE(readerActual->nextFrame(actual));
             actual.download(actualHost);
             reference.download(referenceHost);
             ASSERT_TRUE(cvtest::norm(actualHost, referenceHost, NORM_INF) == 0);
@@ -544,7 +542,8 @@ CUDA_TEST_P(CheckDecodeSurfaces, Reader)
         cv::Ptr<cv::cudacodec::VideoReader> reader = cv::cudacodec::createVideoReader(inputFile, {}, params);
         cv::cudacodec::FormatInfo fmt = reader->format();
         ASSERT_TRUE(fmt.ulNumDecodeSurfaces == ulNumDecodeSurfaces);
-        for (int i = 0; i < 100; i++) ASSERT_TRUE(reader->grab());
+        GpuMat frame;
+        for (int i = 0; i < 100; i++) ASSERT_TRUE(reader->nextFrame(frame));
     }
 
     {
@@ -553,7 +552,8 @@ CUDA_TEST_P(CheckDecodeSurfaces, Reader)
         cv::Ptr<cv::cudacodec::VideoReader> reader = cv::cudacodec::createVideoReader(inputFile, {}, params);
         cv::cudacodec::FormatInfo fmt = reader->format();
         ASSERT_TRUE(fmt.ulNumDecodeSurfaces == ulNumDecodeSurfaces + 1);
-        for (int i = 0; i < 100; i++) ASSERT_TRUE(reader->grab());
+        GpuMat frame;
+        for (int i = 0; i < 100; i++) ASSERT_TRUE(reader->nextFrame(frame));
     }
 }