Merge pull request #27284 from dkurt:java_video_capture_read

dkurt · web-flow · commit 67ba045e3b0c · 2025-05-14T17:01:45.000+03:00
Java VideoCapture buffered stream constructor #27284 ### Pull Request Readiness Checklist resolves #26809 See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request - [x] I agree to contribute to the project under Apache 2 License. - [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV - [x] The PR is proposed to the proper branch - [x] There is a reference to the original bug report and related work - [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable Patch to opencv_extra has the same branch name. - [x] The feature is well documented and sample code can be built with the project CMake
diff --git a/modules/java/generator/gen_java.py b/modules/java/generator/gen_java.py
@@ -65,6 +65,7 @@ def checkFileRemap(path):
     "char"    : { "j_type" : "char", "jn_type" : "char", "jni_type" : "jchar", "suffix" : "C" },
     "int"     : { "j_type" : "int", "jn_type" : "int", "jni_type" : "jint", "suffix" : "I" },
     "long"    : { "j_type" : "int", "jn_type" : "int", "jni_type" : "jint", "suffix" : "I" },
+    "long long" : { "j_type" : "long", "jn_type" : "long", "jni_type" : "jlong", "suffix" : "J" },
     "float"   : { "j_type" : "float", "jn_type" : "float", "jni_type" : "jfloat", "suffix" : "F" },
     "double"  : { "j_type" : "double", "jn_type" : "double", "jni_type" : "jdouble", "suffix" : "D" },
     "size_t"  : { "j_type" : "long", "jn_type" : "long", "jni_type" : "jlong", "suffix" : "J" },
@@ -89,6 +90,13 @@ def checkFileRemap(path):
         'v_type': 'string',
         'j_import': 'java.lang.String'
     },
+    "byte[]": {
+        "j_type" : "byte[]",
+        "jn_type": "byte[]",
+        "jni_type": "jbyteArray",
+        "jni_name": "n_%(n)s",
+        "jni_var": "char* n_%(n)s = reinterpret_cast<char*>(env->GetByteArrayElements(%(n)s, NULL))",
+    },
 }
 
 # Defines a rule to add extra prefixes for names from specific namespaces.
@@ -511,14 +519,14 @@ def add_class(self, decl):
 
         if classinfo.base:
             classinfo.addImports(classinfo.base)
-        type_dict.setdefault("Ptr_"+name, {}).update(
-            { "j_type" : classinfo.jname,
-              "jn_type" : "long", "jn_args" : (("__int64", ".getNativeObjAddr()"),),
-              "jni_name" : "*((Ptr<"+classinfo.fullNameCPP()+">*)%(n)s_nativeObj)", "jni_type" : "jlong",
-              "suffix" : "J",
-              "j_import" : "org.opencv.%s.%s" % (self.module, classinfo.jname)
+        if ("Ptr_"+name) not in type_dict:
+            type_dict["Ptr_"+name] = {
+                "j_type" : classinfo.jname,
+                "jn_type" : "long", "jn_args" : (("__int64", ".getNativeObjAddr()"),),
+                "jni_name" : "*((Ptr<"+classinfo.fullNameCPP()+">*)%(n)s_nativeObj)", "jni_type" : "jlong",
+                "suffix" : "J",
+                "j_import" : "org.opencv.%s.%s" % (self.module, classinfo.jname)
             }
-        )
         logging.info('ok: class %s, name: %s, base: %s', classinfo, name, classinfo.base)
 
     def add_const(self, decl, enumType=None): # [ "const cname", val, [], [] ]
diff --git a/modules/python/src2/cv2.cpp b/modules/python/src2/cv2.cpp
@@ -45,7 +45,9 @@ typedef std::vector<DMatch> vector_DMatch;
 typedef std::vector<String> vector_String;
 typedef std::vector<std::string> vector_string;
 typedef std::vector<Scalar> vector_Scalar;
+#ifdef HAVE_OPENCV_OBJDETECT
 typedef std::vector<aruco::Dictionary> vector_Dictionary;
+#endif // HAVE_OPENCV_OBJDETECT
 
 typedef std::vector<std::vector<char> > vector_vector_char;
 typedef std::vector<std::vector<Point> > vector_vector_Point;
diff --git a/modules/python/src2/cv2_convert.hpp b/modules/python/src2/cv2_convert.hpp
@@ -182,6 +182,29 @@ struct PyOpenCV_Converter
     }
 };
 
+// There is conflict between "long long" and "int64".
+// They are the same type on some 32-bit platforms.
+template<typename T>
+struct PyOpenCV_Converter
+    < T, typename std::enable_if< std::is_same<long long, T>::value && !std::is_same<long long, int64>::value >::type >
+{
+    static inline PyObject* from(const long long& value)
+    {
+        return PyLong_FromLongLong(value);
+    }
+
+    static inline bool to(PyObject* obj, long long& value, const ArgInfo& info)
+    {
+        CV_UNUSED(info);
+        if(!obj || obj == Py_None)
+            return true;
+        else if(PyLong_Check(obj))
+            value = PyLong_AsLongLong(obj);
+        else
+            return false;
+        return value != (long long)-1 || !PyErr_Occurred();
+    }
+};
 
 // --- uchar
 template<> bool pyopencv_to(PyObject* obj, uchar& value, const ArgInfo& info);
diff --git a/modules/python/src2/hdr_parser.py b/modules/python/src2/hdr_parser.py
@@ -190,6 +190,8 @@ def parse_arg(self, arg_str, argno):
                 angle_stack[-1] += 1
             elif arg_type == "struct":
                 arg_type += " " + w
+            elif prev_w in ["signed", "unsigned", "short", "long"] and w in ["char", "short", "int", "long"]:
+                arg_type += " " + w
             elif arg_type and arg_type != "~":
                 arg_name = " ".join(word_list[wi:])
                 break
diff --git a/modules/python/src2/typing_stubs_generation/predefined_types.py b/modules/python/src2/typing_stubs_generation/predefined_types.py
@@ -28,6 +28,7 @@
     PrimitiveTypeNode.int_("uint32_t"),
     PrimitiveTypeNode.int_("size_t"),
     PrimitiveTypeNode.int_("int64_t"),
+    PrimitiveTypeNode.int_("long long"),
     PrimitiveTypeNode.float_("float"),
     PrimitiveTypeNode.float_("double"),
     PrimitiveTypeNode.bool_("bool"),
diff --git a/modules/videoio/include/opencv2/videoio.hpp b/modules/videoio/include/opencv2/videoio.hpp
@@ -726,8 +726,14 @@ class CV_EXPORTS_W IStreamReader
 public:
     virtual ~IStreamReader();
 
-    /** @brief Read bytes from stream */
-    virtual long long read(char* buffer, long long size) = 0;
+    /** @brief Read bytes from stream
+     *
+     * @param buffer already allocated buffer of at least @p size bytes
+     * @param size maximum number of bytes to read
+     *
+     * @return actual number of read bytes
+     */
+    CV_WRAP virtual long long read(char* buffer, long long size) = 0;
 
     /** @brief Sets the stream position
      *
@@ -736,7 +742,7 @@ class CV_EXPORTS_W IStreamReader
      *
      * @see fseek
      */
-    virtual long long seek(long long offset, int origin) = 0;
+    CV_WRAP virtual long long seek(long long offset, int origin) = 0;
 };
 
 class IVideoCapture;
diff --git a/modules/videoio/misc/java/filelist_common b/modules/videoio/misc/java/filelist_common
@@ -0,0 +1 @@
+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
@@ -0,0 +1,40 @@
+{
+    "ManualFuncs" : {
+        "IStreamReader" : {
+            "IStreamReader" : {
+                "j_code"   : [
+                    "\n",
+                    "/**",
+                    " * Constructor of streaming callback object with abstract 'read' and 'seek' methods that should be implemented in Java code.<br>",
+                    " * <b>NOTE</b>: Implemented callbacks should be called from the creation thread to avoid JNI performance degradation",
+                    "*/",
+                    "protected IStreamReader() { nativeObj = 0; }",
+                    "\n"
+                ],
+                "jn_code": [],
+                "cpp_code": []
+            }
+        }
+    },
+    "func_arg_fix" : {
+        "read": { "buffer": {"ctype" : "byte[]"} }
+    },
+    "type_dict": {
+        "Ptr_IStreamReader": {
+            "j_type": "IStreamReader",
+            "jn_type": "IStreamReader",
+            "jni_name": "n_%(n)s",
+            "jni_type": "jobject",
+            "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
@@ -0,0 +1,97 @@
+#include "videoio_converters.hpp"
+
+class JNIEnvHandler
+{
+public:
+    JNIEnvHandler(JavaVM* _vm) : vm(_vm)
+    {
+        jint res = vm->GetEnv((void**)&env, JNI_VERSION_1_6);
+        if (res == JNI_EDETACHED)
+        {
+#ifdef __ANDROID__
+            res = vm->AttachCurrentThread(&env, NULL);
+#else
+            res = vm->AttachCurrentThread((void**)&env, NULL);
+#endif // __ANDROID__
+            detach = true;
+        }
+    }
+
+    ~JNIEnvHandler()
+    {
+        if (env && detach)
+        {
+            vm->DetachCurrentThread();
+        }
+    }
+
+    JavaVM* vm;
+    JNIEnv* env = nullptr;
+    bool detach = false;
+};
+
+JavaStreamReader::JavaStreamReader(JNIEnv* env, jobject _obj)
+{
+    obj = env->NewGlobalRef(_obj);
+    jclass cls = env->GetObjectClass(obj);
+    m_read = env->GetMethodID(cls, "read", "([BJ)J");
+    m_seek = env->GetMethodID(cls, "seek", "(JI)J");
+    env->GetJavaVM(&vm);
+}
+
+JavaStreamReader::~JavaStreamReader()
+{
+    JNIEnvHandler handler(vm);
+    JNIEnv* env = handler.env;
+    if (!env)
+        return;
+    env->DeleteGlobalRef(obj);
+}
+
+long long JavaStreamReader::read(char* buffer, long long size)
+{
+    if (!m_read)
+        return 0;
+    JNIEnvHandler handler(vm);
+    JNIEnv* env = handler.env;
+    if (!env)
+        return 0;
+    jbyteArray jBuffer = env->NewByteArray(static_cast<jsize>(size));
+    if (!jBuffer)
+        return 0;
+    jlong res = env->CallLongMethod(obj, m_read, jBuffer, size);
+    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)
+{
+    JNIEnvHandler handler(vm);
+    JNIEnv* env = handler.env;
+    if (!env)
+        return 0;
+    if (!m_seek)
+        return 0;
+    return env->CallLongMethod(obj, m_seek, offset, way);
+}
+
+// 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
@@ -0,0 +1,25 @@
+#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, jobject obj);
+    ~JavaStreamReader();
+    long long read(char* buffer, long long size) CV_OVERRIDE;
+    long long seek(long long offset, int way) CV_OVERRIDE;
+
+private:
+    JavaVM* vm;
+    jobject obj;
+    jmethodID m_read, m_seek;
+};
+
+jobject vector_VideoCaptureAPIs_to_List(JNIEnv* env, std::vector<cv::VideoCaptureAPIs>& vs);
+
+#endif
diff --git a/modules/videoio/misc/java/test/VideoCaptureTest.java b/modules/videoio/misc/java/test/VideoCaptureTest.java

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+misc/java/src/cpp/videoio_converters.hpp`