opencv
diff --git a/‎modules/videoio/include/opencv2/videoio.hpp
Copy file name to clipboard
+40Lines changed: 40 additions & 0 deletions b/‎modules/videoio/include/opencv2/videoio.hpp
Copy file name to clipboard
+40Lines changed: 40 additions & 0 deletions
diff --git a/‎modules/videoio/include/opencv2/videoio/registry.hpp
Copy file name to clipboard
+10Lines changed: 10 additions & 0 deletions b/‎modules/videoio/include/opencv2/videoio/registry.hpp
Copy file name to clipboard
+10Lines changed: 10 additions & 0 deletions
diff --git a/‎modules/videoio/include/opencv2/videoio/utils.private.hpp
Copy file name to clipboard
+31Lines changed: 31 additions & 0 deletions b/‎modules/videoio/include/opencv2/videoio/utils.private.hpp
Copy file name to clipboard
+31Lines changed: 31 additions & 0 deletions
diff --git a/‎modules/videoio/misc/objc/gen_dict.json
Copy file name to clipboard
+2-1Lines changed: 2 additions & 1 deletion b/‎modules/videoio/misc/objc/gen_dict.json
Copy file name to clipboard
+2-1Lines changed: 2 additions & 1 deletion
diff --git a/‎modules/videoio/misc/python/pyopencv_videoio.hpp
Copy file name to clipboard
+110Lines changed: 110 additions & 0 deletions b/‎modules/videoio/misc/python/pyopencv_videoio.hpp
Copy file name to clipboard
+110Lines changed: 110 additions & 0 deletions
diff --git a/‎modules/videoio/misc/python/test/test_videoio.py
Copy file name to clipboard
+66Lines changed: 66 additions & 0 deletions b/‎modules/videoio/misc/python/test/test_videoio.py
Copy file name to clipboard
+66Lines changed: 66 additions & 0 deletions
diff --git a/‎modules/videoio/src/backend.hpp
Copy file name to clipboard
+5Lines changed: 5 additions & 0 deletions b/‎modules/videoio/src/backend.hpp
Copy file name to clipboard
+5Lines changed: 5 additions & 0 deletions
@@ -719,6 +719,25 @@ enum VideoCaptureOBSensorProperties{
 
 //! @} videoio_flags_others
 
+/** @brief Read data stream interface
+ */
+class CV_EXPORTS_W IStreamReader
+{
+public:
+    virtual ~IStreamReader();
+
+    /** @brief Read bytes from stream */
+    virtual long long read(char* buffer, long long size) = 0;
+
+    /** @brief Sets the stream position
+     *
+     * @param offset Seek offset
+     * @param origin SEEK_SET / SEEK_END / SEEK_CUR
+     *
+     * @see fseek
+     */
+    virtual long long seek(long long offset, int origin) = 0;
+};
 
 class IVideoCapture;
 //! @cond IGNORED
@@ -798,6 +817,14 @@ class CV_EXPORTS_W VideoCapture
     */
     CV_WRAP explicit VideoCapture(int index, int apiPreference, const std::vector<int>& params);
 
+    /** @overload
+    @brief Opens a video using data stream.
+
+    The `params` parameter allows to specify extra parameters encoded as pairs `(paramId_1, paramValue_1, paramId_2, paramValue_2, ...)`.
+    See cv::VideoCaptureProperties
+    */
+    CV_WRAP VideoCapture(const Ptr<IStreamReader>& source, int apiPreference, const std::vector<int>& params);
+
     /** @brief Default destructor
 
     The method first calls VideoCapture::release to close the already opened file or camera.
@@ -852,6 +879,19 @@ class CV_EXPORTS_W VideoCapture
     */
     CV_WRAP virtual bool open(int index, int apiPreference, const std::vector<int>& params);
 
+    /** @brief Opens a video using data stream.
+
+    @overload
+
+    The `params` parameter allows to specify extra parameters encoded as pairs `(paramId_1, paramValue_1, paramId_2, paramValue_2, ...)`.
+    See cv::VideoCaptureProperties
+
+    @return `true` if the file has been successfully opened
+
+    The method first calls VideoCapture::release to close the already opened file or camera.
+     */
+    CV_WRAP virtual bool open(const Ptr<IStreamReader>& source, int apiPreference, const std::vector<int>& params);
+
     /** @brief Returns true if video capturing has been initialized already.
 
     If the previous call to VideoCapture constructor or VideoCapture::open() succeeded, the method returns
 
@@ -35,6 +35,9 @@ CV_EXPORTS_W std::vector<VideoCaptureAPIs> getCameraBackends();
 /** @brief Returns list of available backends which works via `cv::VideoCapture(filename)` */
 CV_EXPORTS_W std::vector<VideoCaptureAPIs> getStreamBackends();
 
+/** @brief Returns list of available backends which works via `cv::VideoCapture(buffer)` */
+CV_EXPORTS_W std::vector<VideoCaptureAPIs> getStreamBufferedBackends();
+
 /** @brief Returns list of available backends which works via `cv::VideoWriter()` */
 CV_EXPORTS_W std::vector<VideoCaptureAPIs> getWriterBackends();
 
@@ -58,6 +61,13 @@ CV_EXPORTS_W std::string getStreamBackendPluginVersion(
     CV_OUT int& version_API
 );
 
+/** @brief Returns description and ABI/API version of videoio plugin's buffer capture interface */
+CV_EXPORTS_W std::string getStreamBufferedBackendPluginVersion(
+    VideoCaptureAPIs api,
+    CV_OUT int& version_ABI,
+    CV_OUT int& version_API
+);
+
 /** @brief Returns description and ABI/API version of videoio plugin's writer interface */
 CV_EXPORTS_W std::string getWriterBackendPluginVersion(
     VideoCaptureAPIs api,
 
@@ -10,6 +10,37 @@
 
 namespace cv {
 CV_EXPORTS std::string icvExtractPattern(const std::string& filename, unsigned *offset);
+
+class PluginStreamReader : public IStreamReader
+{
+public:
+    PluginStreamReader(void* _opaque,
+                       long long (*_read)(void* opaque, char* buffer, long long size),
+                       long long (*_seek)(void* opaque, long long offset, int way))
+    {
+        opaque = _opaque;
+        readCallback = _read;
+        seekCallback = _seek;
+    }
+
+    virtual ~PluginStreamReader() {}
+
+    long long read(char* buffer, long long size) override
+    {
+        return readCallback(opaque, buffer, size);
+    }
+
+    long long seek(long long offset, int way) override
+    {
+        return seekCallback(opaque, offset, way);
+    }
+
+private:
+    void* opaque;
+    long long (*readCallback)(void* opaque, char* buffer, long long size);
+    long long (*seekCallback)(void* opaque, long long offset, int way);
+};
+
 }
 
 #endif // OPENCV_VIDEOIO_UTILS_PRIVATE_HPP
@@ -14,7 +14,8 @@
     "func_arg_fix" : {
         "VideoCapture" : {
             "(BOOL)open:(int)index apiPreference:(int)apiPreference" : { "open" : {"name" : "openWithIndex"} },
-            "(BOOL)open:(int)index apiPreference:(int)apiPreference params:(IntVector*)params" : { "open" : {"name" : "openWithIndexAndParameters"} }
+            "(BOOL)open:(int)index apiPreference:(int)apiPreference params:(IntVector*)params" : { "open" : {"name" : "openWithIndexAndParameters"} },
+            "(BOOL)open:(IStreamReader*)source apiPreference:(int)apiPreference params:(IntVector*)params" : { "open" : {"name" : "openWithStreamReader"} }
         }
     }
 }
@@ -31,4 +31,114 @@ template<> bool pyopencv_to(PyObject* obj, cv::VideoCapture& stream, const ArgIn
     return true;
 }
 
+class PythonStreamReader : public cv::IStreamReader
+{
+public:
+    PythonStreamReader(PyObject* _obj = nullptr) : obj(_obj)
+    {
+        if (obj)
+            Py_INCREF(obj);
+    }
+
+    ~PythonStreamReader()
+    {
+        if (obj)
+            Py_DECREF(obj);
+    }
+
+    long long read(char* buffer, long long size) CV_OVERRIDE
+    {
+        if (!obj)
+            return 0;
+
+        PyObject* ioBase = reinterpret_cast<PyObject*>(obj);
+
+        PyGILState_STATE gstate;
+        gstate = PyGILState_Ensure();
+
+        PyObject* py_size = pyopencv_from(static_cast<int>(size));
+
+        PyObject* res = PyObject_CallMethodObjArgs(ioBase, PyString_FromString("read"), py_size, NULL);
+        bool hasPyReadError = PyErr_Occurred() != nullptr;
+        char* src = PyBytes_AsString(res);
+        size_t len = static_cast<size_t>(PyBytes_Size(res));
+        bool hasPyBytesError = PyErr_Occurred() != nullptr;
+        if (src && len <= static_cast<size_t>(size))
+        {
+            std::memcpy(buffer, src, len);
+        }
+        Py_DECREF(res);
+        Py_DECREF(py_size);
+
+        PyGILState_Release(gstate);
+
+        if (hasPyReadError)
+            CV_Error(cv::Error::StsError, "Python .read() call error");
+        if (hasPyBytesError)
+            CV_Error(cv::Error::StsError, "Python buffer access error");
+
+        CV_CheckLE(len, static_cast<size_t>(size), "Stream chunk size should be less or equal than requested size");
+
+        return len;
+    }
+
+    long long seek(long long offset, int way) CV_OVERRIDE
+    {
+        if (!obj)
+            return 0;
+
+        PyObject* ioBase = reinterpret_cast<PyObject*>(obj);
+
+        PyGILState_STATE gstate;
+        gstate = PyGILState_Ensure();
+
+        PyObject* py_offset = pyopencv_from(static_cast<int>(offset));
+        PyObject* py_whence = pyopencv_from(way);
+
+        PyObject* res = PyObject_CallMethodObjArgs(ioBase, PyString_FromString("seek"), py_offset, py_whence, NULL);
+        bool hasPySeekError = PyErr_Occurred() != nullptr;
+        long long pos = PyLong_AsLongLong(res);
+        bool hasPyConvertError = PyErr_Occurred() != nullptr;
+        Py_DECREF(res);
+        Py_DECREF(py_offset);
+        Py_DECREF(py_whence);
+
+        PyGILState_Release(gstate);
+
+        if (hasPySeekError)
+            CV_Error(cv::Error::StsError, "Python .seek() call error");
+        if (hasPyConvertError)
+            CV_Error(cv::Error::StsError, "Python .seek() result => long long conversion error");
+        return pos;
+    }
+
+private:
+    PyObject* obj;
+};
+
+template<>
+bool pyopencv_to(PyObject* obj, Ptr<cv::IStreamReader>& p, const ArgInfo&)
+{
+    if (!obj)
+        return false;
+
+    PyObject* ioModule = PyImport_ImportModule("io");
+    PyObject* type = PyObject_GetAttrString(ioModule, "BufferedIOBase");
+    Py_DECREF(ioModule);
+    bool isValidPyType = PyObject_IsInstance(obj, type) == 1;
+    Py_DECREF(type);
+
+    if (!isValidPyType)
+    {
+        PyErr_SetString(PyExc_TypeError, "Input stream should be derived from io.BufferedIOBase");
+        return false;
+    }
+
+    if (!PyErr_Occurred()) {
+        p = makePtr<PythonStreamReader>(obj);
+        return true;
+    }
+    return false;
+}
+
 #endif // HAVE_OPENCV_VIDEOIO
@@ -3,6 +3,8 @@
 
 import numpy as np
 import cv2 as cv
+import io
+import sys
 
 from tests_common import NewOpenCVTests
 
@@ -21,5 +23,69 @@ def test_registry(self):
         for backend in backends:
             self.check_name(cv.videoio_registry.getBackendName(backend))
 
+    def test_capture_stream_file(self):
+        if sys.version_info[0] < 3:
+            raise self.skipTest('Python 3.x required')
+
+        api_pref = None
+        for backend in cv.videoio_registry.getStreamBufferedBackends():
+            if not cv.videoio_registry.hasBackend(backend):
+                continue
+            if not cv.videoio_registry.isBackendBuiltIn(backend):
+                _, abi, api = cv.videoio_registry.getStreamBufferedBackendPluginVersion(backend)
+                if (abi < 1 or (abi == 1 and api < 2)):
+                    continue
+            api_pref = backend
+            break
+
+        if not api_pref:
+            raise self.skipTest("No available backends")
+
+        with open(self.find_file("cv/video/768x576.avi"), "rb") as f:
+            cap = cv.VideoCapture(f, api_pref, [])
+            self.assertTrue(cap.isOpened())
+            hasFrame, frame = cap.read()
+            self.assertTrue(hasFrame)
+            self.assertEqual(frame.shape, (576, 768, 3))
+
+    def test_capture_stream_buffer(self):
+        if sys.version_info[0] < 3:
+            raise self.skipTest('Python 3.x required')
+
+        api_pref = None
+        for backend in cv.videoio_registry.getStreamBufferedBackends():
+            if not cv.videoio_registry.hasBackend(backend):
+                continue
+            if not cv.videoio_registry.isBackendBuiltIn(backend):
+                _, abi, api = cv.videoio_registry.getStreamBufferedBackendPluginVersion(backend)
+                if (abi < 1 or (abi == 1 and api < 2)):
+                    continue
+            api_pref = backend
+            break
+
+        if not api_pref:
+            raise self.skipTest("No available backends")
+
+        class BufferStream(io.BufferedIOBase):
+            def __init__(self, filepath):
+                self.f = open(filepath, "rb")
+
+            def read(self, size=-1):
+                return self.f.read(size)
+
+            def seek(self, offset, whence):
+                return self.f.seek(offset, whence)
+
+            def __del__(self):
+                self.f.close()
+
+        stream = BufferStream(self.find_file("cv/video/768x576.avi"))
+
+        cap = cv.VideoCapture(stream, api_pref, [])
+        self.assertTrue(cap.isOpened())
+        hasFrame, frame = cap.read()
+        self.assertTrue(hasFrame)
+        self.assertEqual(frame.shape, (576, 768, 3))
+
 if __name__ == '__main__':
     NewOpenCVTests.bootstrap()
@@ -18,6 +18,7 @@ class IBackend
     virtual ~IBackend() {}
     virtual Ptr<IVideoCapture> createCapture(int camera, const VideoCaptureParameters& params) const = 0;
     virtual Ptr<IVideoCapture> createCapture(const std::string &filename, const VideoCaptureParameters& params) const = 0;
+    virtual Ptr<IVideoCapture> createCapture(const Ptr<IStreamReader>&stream, const VideoCaptureParameters& params) const = 0;
     virtual Ptr<IVideoWriter> createWriter(const std::string& filename, int fourcc, double fps, const cv::Size& sz,
                                            const VideoWriterParameters& params) const = 0;
 };
@@ -34,15 +35,19 @@ class IBackendFactory
 
 typedef Ptr<IVideoCapture> (*FN_createCaptureFile)(const std::string & filename);
 typedef Ptr<IVideoCapture> (*FN_createCaptureCamera)(int camera);
+typedef Ptr<IVideoCapture> (*FN_createCaptureStream)(const Ptr<IStreamReader>& stream);
 typedef Ptr<IVideoCapture> (*FN_createCaptureFileWithParams)(const std::string & filename, const VideoCaptureParameters& params);
 typedef Ptr<IVideoCapture> (*FN_createCaptureCameraWithParams)(int camera, const VideoCaptureParameters& params);
+typedef Ptr<IVideoCapture> (*FN_createCaptureStreamWithParams)(const Ptr<IStreamReader>& stream, const VideoCaptureParameters& params);
 typedef Ptr<IVideoWriter>  (*FN_createWriter)(const std::string& filename, int fourcc, double fps, const Size& sz,
                                               const VideoWriterParameters& params);
 Ptr<IBackendFactory> createBackendFactory(FN_createCaptureFile createCaptureFile,
                                           FN_createCaptureCamera createCaptureCamera,
+                                          FN_createCaptureStream createCaptureStream,
                                           FN_createWriter createWriter);
 Ptr<IBackendFactory> createBackendFactory(FN_createCaptureFileWithParams createCaptureFile,
                                           FN_createCaptureCameraWithParams createCaptureCamera,
+                                          FN_createCaptureStreamWithParams createCaptureStream,
                                           FN_createWriter createWriter);
 
 Ptr<IBackendFactory> createPluginBackendFactory(VideoCaptureAPIs id, const char* baseName);
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,8 @@`
`14`	`14`	`"func_arg_fix" : {`
`15`	`15`	`"VideoCapture" : {`
`16`	`16`	`"(BOOL)open:(int)index apiPreference:(int)apiPreference" : { "open" : {"name" : "openWithIndex"} },`
`17`		`- "(BOOL)open:(int)index apiPreference:(int)apiPreference params:(IntVector*)params" : { "open" : {"name" : "openWithIndexAndParameters"} }`
	`17`	`+ "(BOOL)open:(int)index apiPreference:(int)apiPreference params:(IntVector*)params" : { "open" : {"name" : "openWithIndexAndParameters"} },`
	`18`	`+ "(BOOL)open:(IStreamReader)source apiPreference:(int)apiPreference params:(IntVector)params" : { "open" : {"name" : "openWithStreamReader"} }`
`18`	`19`	`}`
`19`	`20`	`}`
`20`	`21`	`}`