May 14, 2025 · May 2, 2025 · May 2, 2025 · May 3, 2025 · May 5, 2025 · May 5, 2025
diff --git a/modules/python/src2/typing_stubs_generation/predefined_types.py b/modules/python/src2/typing_stubs_generation/predefined_types.py
        export_name="ExtractMetaCallback",
        required_modules=("gapi",)
    ),

    # videoio, optional
    AliasTypeNode.ref_("IStreamReader", "io.BufferedIOBase"),
 )

 PREDEFINED_TYPES = dict(
diff --git a/modules/videoio/include/opencv2/videoio.hpp b/modules/videoio/include/opencv2/videoio.hpp

 /** @brief Read data stream interface
 */
 classCV_EXPORTS_W IStreamReader
 classCV_EXPORTS IStreamReader
 {
 public:
    virtual ~IStreamReader();
diff --git a/modules/videoio/misc/java/filelist_common b/modules/videoio/misc/java/filelist_common
 misc/java/src/cpp/videoio_converters.hpp
diff --git a/modules/videoio/misc/java/gen_dict.json b/modules/videoio/misc/java/gen_dict.json
 {
    "type_dict": {
        "Ptr_IStreamReader": {
            "j_type": "IStreamReader",
            "jn_type": "IStreamReader",
            "jni_name": "n_%(n)s",
            "jni_type": "jclass",
            "jni_var": "auto n_%(n)s = makePtr<JavaStreamReader>(env, source)",
            "j_import": "org.opencv.videoio.IStreamReader"
        },
        "vector_VideoCaptureAPIs": {
            "j_type": "List<Integer>",
            "jn_type": "List<Integer>",
            "jni_type": "jobject",
            "jni_var": "std::vector< cv::VideoCaptureAPIs > %(n)s",
            "suffix": "Ljava_util_List",
            "v_type": "vector_VideoCaptureAPIs"
        }
    }
 }
diff --git a/modules/videoio/misc/java/src/cpp/videoio_converters.cpp b/modules/videoio/misc/java/src/cpp/videoio_converters.cpp
 #include "videoio_converters.hpp"

 JavaStreamReader::JavaStreamReader(JNIEnv* _env, jclass _obj) : env(_env), obj(_obj) {}

 long long JavaStreamReader::read(char* buffer, long long size)
 {
    jmethodID m_read = env->GetMethodID(env->GetObjectClass(obj), "read", "([B)J");
    if (!m_read)
        return 0;
    jbyteArray jBuffer = env->NewByteArray(static_cast<jsize>(size));
    if (!jBuffer)
        return 0;
    jlong res = env->CallIntMethod(obj, m_read, jBuffer);
    env->GetByteArrayRegion(jBuffer, 0, static_cast<jsize>(size), reinterpret_cast<jbyte*>(buffer));
    env->DeleteLocalRef(jBuffer);
    return res;
 }

 long long JavaStreamReader::seek(long long offset, int way)
 {
    jmethodID m_seek = env->GetMethodID(env->GetObjectClass(obj), "seek", "(JJ)J");
    if (!m_seek)
        return 0;
    jlong res = env->CallIntMethod(obj, m_seek, offset, way);
    return res;
 }

 // Same as dnn::vector_Target_to_List
 jobject vector_VideoCaptureAPIs_to_List(JNIEnv* env, std::vector<cv::VideoCaptureAPIs>& vs)
 {
    static jclass juArrayList   = ARRAYLIST(env);
    static jmethodID m_create   = CONSTRUCTOR(env, juArrayList);
    jmethodID m_add       = LIST_ADD(env, juArrayList);

    static jclass jInteger = env->FindClass("java/lang/Integer");
    static jmethodID m_create_Integer = env->GetMethodID(jInteger, "<init>", "(I)V");

    jobject result = env->NewObject(juArrayList, m_create, vs.size());
    for (size_t i = 0; i < vs.size(); ++i)
    {
        jobject element = env->NewObject(jInteger, m_create_Integer, vs[i]);
        env->CallBooleanMethod(result, m_add, element);
        env->DeleteLocalRef(element);
    }
    return result;
 }
diff --git a/modules/videoio/misc/java/src/cpp/videoio_converters.hpp b/modules/videoio/misc/java/src/cpp/videoio_converters.hpp
 #ifndef VIDEOIO_CONVERTERS_HPP
 #define VIDEOIO_CONVERTERS_HPP

 #include <jni.h>
 #include "opencv_java.hpp"
 #include "opencv2/core.hpp"
 #include "opencv2/videoio/videoio.hpp"

 class JavaStreamReader : public cv::IStreamReader
 {
 public:
    JavaStreamReader(JNIEnv* env, jclass obj);
    long long read(char* buffer, long long size) CV_OVERRIDE;
    long long seek(long long offset, int way) CV_OVERRIDE;

 private:
    JNIEnv* env;
    jclass obj;
 };

 jobject vector_VideoCaptureAPIs_to_List(JNIEnv* env, std::vector<cv::VideoCaptureAPIs>& vs);

 #endif
diff --git a/modules/videoio/misc/java/src/java/videoio+IStreamReader.java b/modules/videoio/misc/java/src/java/videoio+IStreamReader.java
 package org.opencv.videoio;

 public interface IStreamReader {
    public long read(byte[] buffer);
    public long seek(long offset, long origin);
 }
diff --git a/modules/videoio/misc/java/test/VideoCaptureTest.java b/modules/videoio/misc/java/test/VideoCaptureTest.java
 package org.opencv.test.videoio;

 import java.util.List;
 import java.io.File;
 import java.io.RandomAccessFile;
 import java.io.IOException;
 import java.io.FileNotFoundException;

 import org.opencv.core.Mat;
 import org.opencv.core.Size;
 import org.opencv.core.MatOfInt;
 import org.opencv.videoio.Videoio;
 import org.opencv.videoio.VideoCapture;
 import org.opencv.videoio.IStreamReader;

 import org.opencv.test.OpenCVTestCase;

 public class VideoCaptureTest extends OpenCVTestCase {
    private final static String ENV_OPENCV_TEST_DATA_PATH = "OPENCV_TEST_DATA_PATH";

    private VideoCapture capture;
    private boolean isOpened;
    private boolean isSucceed;
    private File testDataPath;

    @Override
    protected void setUp() throws Exception {
        super.setUp();

        capture = null;
        isTestCaseEnabled = false;
        isSucceed = false;
        isOpened = false;

        String envTestDataPath = System.getenv(ENV_OPENCV_TEST_DATA_PATH);

        if(envTestDataPath == null) throw new Exception(ENV_OPENCV_TEST_DATA_PATH + " has to be defined!");

        testDataPath = new File(envTestDataPath);
    }

    public void testGrab() {
        assertNotNull(capture);
    }

    public void testConstructorStream() throws FileNotFoundException {
        // Check backend is available
        Integer apiPref = Videoio.CAP_ANY;
        for (Integer backend : Videoio.getStreamBufferedBackends())
        {
            if (!Videoio.hasBackend(backend))
                continue;
            if (!Videoio.isBackendBuiltIn(backend))
            {
                int[] abi = new int[1], api = new int[1];
                Videoio.getStreamBufferedBackendPluginVersion(backend, abi, api);
                if (abi[0] < 1 || (abi[0] == 1 && api[0] < 2))
                    continue;
            }
            apiPref = backend;
            break;
        }
        if (apiPref == Videoio.CAP_ANY)
        {
            throw new TestSkipException();
        }

        RandomAccessFile f = new RandomAccessFile(new File(testDataPath, "cv/video/768x576.avi"), "r");

        IStreamReader stream = new IStreamReader()
        {
            @Override
            public long read(byte[] buffer)
            {
                try
                {
                    return f.read(buffer);
                }
                catch (IOException e)
                {
                    System.out.println(e.getMessage());
                    return 0;
                }
            }

            @Override
            public long seek(long offset, long origin)
            {
                try
                {
                    if (origin == 0)
                    {
                        f.seek(offset);
                        return offset;
                    }
                    else
                        return 0;
                }
                catch (IOException e)
                {
                    System.out.println(e.getMessage());
                    return 0;
                }
            }
        };
        capture = new VideoCapture(stream, apiPref, new MatOfInt());
        assertNotNull(capture);
        assertTrue(capture.isOpened());

        Mat frame = new Mat();
        assertTrue(capture.read(frame));
        assertEquals(frame.rows(), 576);
        assertEquals(frame.cols(), 768);
    }
 }
diff --git a/modules/videoio/src/backend_plugin.cpp b/modules/videoio/src/backend_plugin.cpp
                    auto is = reinterpret_cast<IStreamReader*>(opaque);
                    try {
                        return is->read(buffer, size);
                    } catch (...) {
                        CV_LOG_WARNING(NULL, "IStreamReader::read(" << size << ") failed");
                    } catch (std::exception& e) {
                        CV_LOG_WARNING(NULL, "IStreamReader::read(" << size << ") failed: " << e.what());
                        return 0;
                    }
                },
                    auto is = reinterpret_cast<IStreamReader*>(opaque);
                    try {
                        return is->seek(offset, way);
                    } catch (...) {
                        CV_LOG_WARNING(NULL, "IStreamReader::seek(" << offset << ", way=" << way << ") failed");
                    } catch (std::exception& e) {
                        CV_LOG_WARNING(NULL, "IStreamReader::seek(" << offset << ", way=" << way << ") failed: " << e.what());
                        return -1;
                    }
                }, c_params, n_params, &capture))
Original file line number	Diff line number	Diff line change
Expand Up		@@ -264,6 +264,9 @@
		export_name="ExtractMetaCallback",
		required_modules=("gapi",)
		),

		# videoio, optional
		AliasTypeNode.ref_("IStreamReader", "io.BufferedIOBase"),
		)

		PREDEFINED_TYPES = dict(
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -721,7 +721,7 @@ enum VideoCaptureOBSensorProperties{

		/** @brief Read data stream interface
		*/
		classCV_EXPORTS_W IStreamReader
		classCV_EXPORTS IStreamReader
dkurt marked this conversation as resolved. OutdatedShow resolvedHide resolved
		{
		public:
		virtual ~IStreamReader();
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,20 @@
		{
		"type_dict": {
		"Ptr_IStreamReader": {
		"j_type": "IStreamReader",
		"jn_type": "IStreamReader",
		"jni_name": "n_%(n)s",
		"jni_type": "jclass",
		"jni_var": "auto n_%(n)s = makePtr<JavaStreamReader>(env, source)",
		"j_import": "org.opencv.videoio.IStreamReader"
		},
		"vector_VideoCaptureAPIs": {
		"j_type": "List<Integer>",
		"jn_type": "List<Integer>",
		"jni_type": "jobject",
		"jni_var": "std::vector< cv::VideoCaptureAPIs > %(n)s",
		"suffix": "Ljava_util_List",
		"v_type": "vector_VideoCaptureAPIs"
		}
		}
		}
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,46 @@
		#include "videoio_converters.hpp"

		JavaStreamReader::JavaStreamReader(JNIEnv* _env, jclass _obj) : env(_env), obj(_obj) {}

		long long JavaStreamReader::read(char* buffer, long long size)
		{
		jmethodID m_read = env->GetMethodID(env->GetObjectClass(obj), "read", "([B)J");
		if (!m_read)
		return 0;
		jbyteArray jBuffer = env->NewByteArray(static_cast<jsize>(size));
		if (!jBuffer)
		return 0;
		jlong res = env->CallIntMethod(obj, m_read, jBuffer);
		env->GetByteArrayRegion(jBuffer, 0, static_cast<jsize>(size), reinterpret_cast<jbyte*>(buffer));
		env->DeleteLocalRef(jBuffer);
		return res;
		}

		long long JavaStreamReader::seek(long long offset, int way)
		{
		jmethodID m_seek = env->GetMethodID(env->GetObjectClass(obj), "seek", "(JJ)J");
		if (!m_seek)
		return 0;
		jlong res = env->CallIntMethod(obj, m_seek, offset, way);
		return res;
		}

		// Same as dnn::vector_Target_to_List
		jobject vector_VideoCaptureAPIs_to_List(JNIEnv* env, std::vector<cv::VideoCaptureAPIs>& vs)
		{
		static jclass juArrayList = ARRAYLIST(env);
		static jmethodID m_create = CONSTRUCTOR(env, juArrayList);
		jmethodID m_add = LIST_ADD(env, juArrayList);

		static jclass jInteger = env->FindClass("java/lang/Integer");
		static jmethodID m_create_Integer = env->GetMethodID(jInteger, "<init>", "(I)V");

		jobject result = env->NewObject(juArrayList, m_create, vs.size());
		for (size_t i = 0; i < vs.size(); ++i)
		{
		jobject element = env->NewObject(jInteger, m_create_Integer, vs[i]);
		env->CallBooleanMethod(result, m_add, element);
		env->DeleteLocalRef(element);
		}
		return result;
		}
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,23 @@
		#ifndef VIDEOIO_CONVERTERS_HPP
		#define VIDEOIO_CONVERTERS_HPP

		#include <jni.h>
		#include "opencv_java.hpp"
		#include "opencv2/core.hpp"
		#include "opencv2/videoio/videoio.hpp"

		class JavaStreamReader : public cv::IStreamReader
		{
		public:
		JavaStreamReader(JNIEnv* env, jclass obj);
		long long read(char* buffer, long long size) CV_OVERRIDE;
		long long seek(long long offset, int way) CV_OVERRIDE;

		private:
		JNIEnv* env;
		jclass obj;
		};

		jobject vector_VideoCaptureAPIs_to_List(JNIEnv* env, std::vector<cv::VideoCaptureAPIs>& vs);

		#endif
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,6 @@
		package org.opencv.videoio;

		public interface IStreamReader {
		public long read(byte[] buffer);
		public long seek(long offset, long origin);
		}
Original file line number	Diff line number	Diff line change
		@@ -1,27 +1,41 @@
		package org.opencv.test.videoio;

		import java.util.List;
		import java.io.File;
		import java.io.RandomAccessFile;
		import java.io.IOException;
		import java.io.FileNotFoundException;

		import org.opencv.core.Mat;
		import org.opencv.core.Size;
		import org.opencv.core.MatOfInt;
		import org.opencv.videoio.Videoio;
		import org.opencv.videoio.VideoCapture;
		import org.opencv.videoio.IStreamReader;

		import org.opencv.test.OpenCVTestCase;

		public class VideoCaptureTest extends OpenCVTestCase {
		private final static String ENV_OPENCV_TEST_DATA_PATH = "OPENCV_TEST_DATA_PATH";

		private VideoCapture capture;
		private boolean isOpened;
		private boolean isSucceed;
		private File testDataPath;

		@Override
		protected void setUp() throws Exception {
		super.setUp();

		capture = null;
		isTestCaseEnabled = false;
		isSucceed = false;
		isOpened = false;

		String envTestDataPath = System.getenv(ENV_OPENCV_TEST_DATA_PATH);

		if(envTestDataPath == null) throw new Exception(ENV_OPENCV_TEST_DATA_PATH + " has to be defined!");

		testDataPath = new File(envTestDataPath);
		}

		public void testGrab() {
Expand DownExpand Up		@@ -61,4 +75,73 @@ public void testConstructorWithIndexAndExplicitlySpecifiedAPI() {
		assertNotNull(capture);
		}

		public void testConstructorStream() throws FileNotFoundException {
		// Check backend is available
		Integer apiPref = Videoio.CAP_ANY;
		for (Integer backend : Videoio.getStreamBufferedBackends())
		{
		if (!Videoio.hasBackend(backend))
		continue;
		if (!Videoio.isBackendBuiltIn(backend))
		{
		int[] abi = new int[1], api = new int[1];
		Videoio.getStreamBufferedBackendPluginVersion(backend, abi, api);
		if (abi[0] < 1 \|\| (abi[0] == 1 && api[0] < 2))
		continue;
		}
		apiPref = backend;
		break;
		}
		if (apiPref == Videoio.CAP_ANY)
		{
		throw new TestSkipException();
		}

		RandomAccessFile f = new RandomAccessFile(new File(testDataPath, "cv/video/768x576.avi"), "r");

		IStreamReader stream = new IStreamReader()
		{
		@Override
		public long read(byte[] buffer)
		{
		try
		{
		return f.read(buffer);
		}
		catch (IOException e)
		{
		System.out.println(e.getMessage());
		return 0;
		}
		}

		@Override
		public long seek(long offset, long origin)
		{
		try
		{
		if (origin == 0)
		{
		f.seek(offset);
		return offset;
		}
		else
		return 0;
		}
		catch (IOException e)
		{
		System.out.println(e.getMessage());
		return 0;
		}
		}
		};
		capture = new VideoCapture(stream, apiPref, new MatOfInt());
		assertNotNull(capture);
		assertTrue(capture.isOpened());

		Mat frame = new Mat();
		assertTrue(capture.read(frame));
		assertEquals(frame.rows(), 576);
		assertEquals(frame.cols(), 768);
		}
		}
Original file line number	Diff line number	Diff line change
Expand Up		@@ -472,8 +472,8 @@ class PluginCapture : public cv::IVideoCapture
		auto is = reinterpret_cast<IStreamReader*>(opaque);
		try {
		return is->read(buffer, size);
		} catch (...) {
		CV_LOG_WARNING(NULL, "IStreamReader::read(" << size << ") failed");
		} catch (std::exception& e) {
		CV_LOG_WARNING(NULL, "IStreamReader::read(" << size << ") failed: " << e.what());
		return 0;
		}
		},
Expand All		@@ -482,8 +482,8 @@ class PluginCapture : public cv::IVideoCapture
		auto is = reinterpret_cast<IStreamReader*>(opaque);
		try {
		return is->seek(offset, way);
		} catch (...) {
		CV_LOG_WARNING(NULL, "IStreamReader::seek(" << offset << ", way=" << way << ") failed");
		} catch (std::exception& e) {
		CV_LOG_WARNING(NULL, "IStreamReader::seek(" << offset << ", way=" << way << ") failed: " << e.what());
		return -1;
		}
		}, c_params, n_params, &capture))
Expand Down