Bug #3276 Java bindings binary compatibility is broken in branch 2.4 fixed.

New version of Java wrappers' generator uses different wrappers for VideoCapture
on Android and desktop to prevent binary compatibility issues.

modules/java/CMakeLists.txt

@@ -41,6 +41,8 @@ file(GLOB handwrittren_aidl_sources  "${CMAKE_CURRENT_SOURCE_DIR}/generator/src/
 if(NOT ANDROID)
   ocv_list_filterout(handwrittren_java_sources "/(engine|android)\\\\+")
   ocv_list_filterout(handwrittren_aidl_sources "/(engine|android)\\\\+")
+  ocv_list_filterout(handwrittren_java_sources "VideoCapture")
+  ocv_list_filterout(handwrittren_cpp_sources "VideoCapture")
 else()
   file(GLOB_RECURSE handwrittren_lib_project_files_rel RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}/android_lib/" "${CMAKE_CURRENT_SOURCE_DIR}/android_lib/*")
   list(REMOVE_ITEM handwrittren_lib_project_files_rel "${ANDROID_MANIFEST_FILE}")
@@ -100,9 +102,15 @@ foreach(module ${OPENCV_JAVA_MODULES})
   # first run of gen_java.py (to get list of generated files)
   file(REMOVE_RECURSE "${CMAKE_CURRENT_BINARY_DIR}/gen_java_out/")
   file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/gen_java_out")
+  if (ANDROID)
+    execute_process(COMMAND ${PYTHON_EXECUTABLE} "${scripts_gen_java}" "${scripts_hdr_parser}" "-android" ${module} ${opencv_public_headers_${module}}
+                  WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/gen_java_out"
+                  OUTPUT_QUIET ERROR_QUIET)
+  else()
     execute_process(COMMAND ${PYTHON_EXECUTABLE} "${scripts_gen_java}" "${scripts_hdr_parser}" ${module} ${opencv_public_headers_${module}}
                   WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/gen_java_out"
                   OUTPUT_QUIET ERROR_QUIET)
+  endif()
   unset(generated_java_sources_${module})
   file(GLOB_RECURSE generated_java_sources_${module} RELATIVE "${CMAKE_CURRENT_BINARY_DIR}/gen_java_out/" "${CMAKE_CURRENT_BINARY_DIR}/gen_java_out/*.java")
   ocv_list_add_prefix(generated_java_sources_${module} "${CMAKE_CURRENT_BINARY_DIR}/")
@@ -123,11 +131,19 @@ endforeach()
 set(step1_depends "${scripts_gen_java}" "${scripts_hdr_parser}" ${opencv_public_headers})
 foreach(module ${OPENCV_JAVA_MODULES})
   # second run of gen_java.py (at build time)
+  if (ANDROID)
+    add_custom_command(OUTPUT ${generated_java_sources_${module}} "${CMAKE_CURRENT_BINARY_DIR}/${module}.cpp"
+                     COMMAND ${PYTHON_EXECUTABLE} "${scripts_gen_java}" "${scripts_hdr_parser}" "-android" ${module} ${opencv_public_headers_${module}}
+                     WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+                     DEPENDS "${scripts_gen_java}" "${scripts_hdr_parser}" ${opencv_public_headers_${module}}
+                    )
+  else()
     add_custom_command(OUTPUT ${generated_java_sources_${module}} "${CMAKE_CURRENT_BINARY_DIR}/${module}.cpp"
                      COMMAND ${PYTHON_EXECUTABLE} "${scripts_gen_java}" "${scripts_hdr_parser}" ${module} ${opencv_public_headers_${module}}
                      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
                      DEPENDS "${scripts_gen_java}" "${scripts_hdr_parser}" ${opencv_public_headers_${module}}
                     )
+  endif()
 endforeach()
 
 # step 2: generate javadoc comments

modules/java/generator/gen_java.py

@@ -1492,8 +1492,15 @@ if __name__ == "__main__":
         hdr_parser_path = os.path.dirname(hdr_parser_path)
     sys.path.append(hdr_parser_path)
     import hdr_parser
+    if (sys.argv[2] == "-android"):
+        class_ignore_list += ("VideoCapture",)
+        ManualFuncs.pop("VideoCapture")
+        module = sys.argv[3]
+        srcfiles = sys.argv[4:]
+    else:
         module = sys.argv[2]
         srcfiles = sys.argv[3:]
+
     #print "Generating module '" + module + "' from headers:\n\t" + "\n\t".join(srcfiles)
     generator = JavaWrapperGenerator()
     generator.gen(srcfiles, module, dstdir)

modules/java/generator/src/cpp/VideoCapture.cpp

+#define LOG_TAG "org.opencv.highgui.VideoCapture"
+#include "common.h"
+
+#include "opencv2/opencv_modules.hpp"
+#ifdef HAVE_OPENCV_HIGHGUI
+
+#include "opencv2/highgui/highgui_c.h"
+#include "opencv2/highgui/highgui.hpp"
+using namespace cv;
+
+
+extern "C" {
+
+//
+//   VideoCapture::VideoCapture()
+//
+
+JNIEXPORT jlong JNICALL Java_org_opencv_highgui_VideoCapture_n_1VideoCapture__
+  (JNIEnv* env, jclass);
+
+JNIEXPORT jlong JNICALL Java_org_opencv_highgui_VideoCapture_n_1VideoCapture__
+  (JNIEnv* env, jclass)
+{
+    try {
+        LOGD("highgui::VideoCapture_n_1VideoCapture__()");
+
+        VideoCapture* _retval_ = new VideoCapture(  );
+
+        return (jlong) _retval_;
+    } catch(cv::Exception e) {
+        LOGD("highgui::VideoCapture_n_1VideoCapture__() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("highgui::VideoCapture_n_1VideoCapture__() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1VideoCapture__()}");
+        return 0;
+    }
+}
+
+
+//
+//   VideoCapture::VideoCapture(int device)
+//
+
+JNIEXPORT jlong JNICALL Java_org_opencv_highgui_VideoCapture_n_1VideoCapture__I
+  (JNIEnv* env, jclass, jint device);
+
+JNIEXPORT jlong JNICALL Java_org_opencv_highgui_VideoCapture_n_1VideoCapture__I
+  (JNIEnv* env, jclass, jint device)
+{
+    try {
+        LOGD("highgui::VideoCapture_n_1VideoCapture__I()");
+
+        VideoCapture* _retval_ = new VideoCapture( device );
+
+        return (jlong) _retval_;
+    } catch(cv::Exception e) {
+        LOGD("highgui::VideoCapture_n_1VideoCapture__I() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("highgui::VideoCapture_n_1VideoCapture__I() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1VideoCapture__I()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  double VideoCapture::get(int propId)
+//
+
+JNIEXPORT jdouble JNICALL Java_org_opencv_highgui_VideoCapture_n_1get
+  (JNIEnv* env, jclass, jlong self, jint propId);
+
+JNIEXPORT jdouble JNICALL Java_org_opencv_highgui_VideoCapture_n_1get
+  (JNIEnv* env, jclass, jlong self, jint propId)
+{
+    try {
+        LOGD("highgui::VideoCapture_n_1get()");
+        VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL
+        double _retval_ = me->get( propId );
+
+        return _retval_;
+    } catch(cv::Exception e) {
+        LOGD("highgui::VideoCapture_n_1get() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("highgui::VideoCapture_n_1get() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1get()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  bool VideoCapture::grab()
+//
+
+JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1grab
+  (JNIEnv* env, jclass, jlong self);
+
+JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1grab
+  (JNIEnv* env, jclass, jlong self)
+{
+    try {
+        LOGD("highgui::VideoCapture_n_1grab()");
+        VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL
+        bool _retval_ = me->grab(  );
+
+        return _retval_;
+    } catch(cv::Exception e) {
+        LOGD("highgui::VideoCapture_n_1grab() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("highgui::VideoCapture_n_1grab() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1grab()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  bool VideoCapture::isOpened()
+//
+
+JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1isOpened
+  (JNIEnv* env, jclass, jlong self);
+
+JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1isOpened
+  (JNIEnv* env, jclass, jlong self)
+{
+    try {
+        LOGD("highgui::VideoCapture_n_1isOpened()");
+        VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL
+        bool _retval_ = me->isOpened(  );
+
+        return _retval_;
+    } catch(cv::Exception e) {
+        LOGD("highgui::VideoCapture_n_1isOpened() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("highgui::VideoCapture_n_1isOpened() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1isOpened()}");
+        return 0;
+    }
+}
+
+
+//
+//  bool VideoCapture::open(int device)
+//
+
+JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1open__JI
+  (JNIEnv* env, jclass, jlong self, jint device);
+
+JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1open__JI
+  (JNIEnv* env, jclass, jlong self, jint device)
+{
+    try {
+        LOGD("highgui::VideoCapture_n_1open__JI()");
+        VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL
+        bool _retval_ = me->open( device );
+
+        return _retval_;
+    } catch(cv::Exception e) {
+        LOGD("highgui::VideoCapture_n_1open__JI() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("highgui::VideoCapture_n_1open__JI() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1open__JI()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  bool VideoCapture::read(Mat image)
+//
+
+JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1read
+  (JNIEnv* env, jclass, jlong self, jlong image_nativeObj);
+
+JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1read
+  (JNIEnv* env, jclass, jlong self, jlong image_nativeObj)
+{
+    try {
+        LOGD("highgui::VideoCapture_n_1read()");
+        VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL
+        Mat& image = *((Mat*)image_nativeObj);
+        bool _retval_ = me->read( image );
+
+        return _retval_;
+    } catch(cv::Exception e) {
+        LOGD("highgui::VideoCapture_n_1read() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("highgui::VideoCapture_n_1read() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1read()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  void VideoCapture::release()
+//
+
+JNIEXPORT void JNICALL Java_org_opencv_highgui_VideoCapture_n_1release
+  (JNIEnv* env, jclass, jlong self);
+
+JNIEXPORT void JNICALL Java_org_opencv_highgui_VideoCapture_n_1release
+  (JNIEnv* env, jclass, jlong self)
+{
+    try {
+
+        LOGD("highgui::VideoCapture_n_1release()");
+
+        VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL
+        me->release(  );
+
+        return;
+    } catch(cv::Exception e) {
+
+        LOGD("highgui::VideoCapture_n_1release() catched cv::Exception: %s", e.what());
+
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return;
+    } catch (...) {
+
+        LOGD("highgui::VideoCapture_n_1release() catched unknown exception (...)");
+
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1release()}");
+        return;
+    }
+}
+
+
+
+//
+//  bool VideoCapture::retrieve(Mat image, int channel = 0)
+//
+
+JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1retrieve__JJI
+  (JNIEnv* env, jclass, jlong self, jlong image_nativeObj, jint channel);
+
+JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1retrieve__JJI
+  (JNIEnv* env, jclass, jlong self, jlong image_nativeObj, jint channel)
+{
+    try {
+
+        LOGD("highgui::VideoCapture_n_1retrieve__JJI()");
+
+        VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL
+        Mat& image = *((Mat*)image_nativeObj);
+        bool _retval_ = me->retrieve( image, channel );
+
+        return _retval_;
+    } catch(cv::Exception e) {
+
+        LOGD("highgui::VideoCapture_n_1retrieve__JJI() catched cv::Exception: %s", e.what());
+
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+
+        LOGD("highgui::VideoCapture_n_1retrieve__JJI() catched unknown exception (...)");
+
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1retrieve__JJI()}");
+        return 0;
+    }
+}
+
+
+
+JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1retrieve__JJ
+  (JNIEnv* env, jclass, jlong self, jlong image_nativeObj);
+
+JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1retrieve__JJ
+  (JNIEnv* env, jclass, jlong self, jlong image_nativeObj)
+{
+    try {
+
+        LOGD("highgui::VideoCapture_n_1retrieve__JJ()");
+
+        VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL
+        Mat& image = *((Mat*)image_nativeObj);
+        bool _retval_ = me->retrieve( image );
+
+        return _retval_;
+    } catch(cv::Exception e) {
+
+        LOGD("highgui::VideoCapture_n_1retrieve__JJ() catched cv::Exception: %s", e.what());
+
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+
+        LOGD("highgui::VideoCapture_n_1retrieve__JJ() catched unknown exception (...)");
+
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1retrieve__JJ()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  bool VideoCapture::set(int propId, double value)
+//
+
+JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1set
+  (JNIEnv* env, jclass, jlong self, jint propId, jdouble value);
+
+JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1set
+  (JNIEnv* env, jclass, jlong self, jint propId, jdouble value)
+{
+    try {
+
+        LOGD("highgui::VideoCapture_n_1set()");
+
+        VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL
+        bool _retval_ = me->set( propId, value );
+
+        return _retval_;
+    } catch(cv::Exception e) {
+
+        LOGD("highgui::VideoCapture_n_1set() catched cv::Exception: %s", e.what());
+
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+
+        LOGD("highgui::VideoCapture_n_1set() catched unknown exception (...)");
+
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1set()}");
+        return 0;
+    }
+}
+
+JNIEXPORT jstring JNICALL Java_org_opencv_highgui_VideoCapture_n_1getSupportedPreviewSizes
+  (JNIEnv *env, jclass, jlong self);
+
+JNIEXPORT jstring JNICALL Java_org_opencv_highgui_VideoCapture_n_1getSupportedPreviewSizes
+  (JNIEnv *env, jclass, jlong self)
+{
+    try {
+
+        LOGD("highgui::VideoCapture_n_1set()");
+
+        VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL
+        union {double prop; const char* name;} u;
+        u.prop = me->get(CV_CAP_PROP_SUPPORTED_PREVIEW_SIZES_STRING);
+        return env->NewStringUTF(u.name);
+    } catch(cv::Exception e) {
+
+        LOGD("highgui::VideoCapture_n_1getSupportedPreviewSizes() catched cv::Exception: %s", e.what());
+
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return env->NewStringUTF("");
+    } catch (...) {
+
+        LOGD("highgui::VideoCapture_n_1getSupportedPreviewSizes() catched unknown exception (...)");
+
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1getSupportedPreviewSizes()}");
+        return env->NewStringUTF("");
+    }
+}
+
+
+
+//
+//  native support for java finalize()
+//  static void VideoCapture::n_delete( __int64 self )
+//
+
+JNIEXPORT void JNICALL Java_org_opencv_highgui_VideoCapture_n_1delete
+  (JNIEnv*, jclass, jlong self);
+
+JNIEXPORT void JNICALL Java_org_opencv_highgui_VideoCapture_n_1delete
+  (JNIEnv*, jclass, jlong self)
+{
+    delete (VideoCapture*) self;
+}
+
+} // extern "C"
+
+#endif // HAVE_OPENCV_HIGHGUI
\ No newline at end of file

modules/java/generator/src/cpp/videocap_compat.cpp

-// emulating the 'old' JNI names existed before the VideoCapture wrapping became automatic
-
-#define LOG_TAG "org.opencv.highgui.VideoCapture"
-#include "common.h"
-
-#include "opencv2/opencv_modules.hpp"
-#ifdef HAVE_OPENCV_HIGHGUI
-
-#include "opencv2/core/version.hpp"
-
-#if (CV_VERSION_EPOCH == 2) && (CV_VERSION_MAJOR == 4)
-extern "C" {
-
-JNIEXPORT jlong JNICALL Java_org_opencv_highgui_VideoCapture_n_1VideoCapture__
-  (JNIEnv* env, jclass c);
-
-JNIEXPORT jlong JNICALL Java_org_opencv_highgui_VideoCapture_VideoCapture_10 (JNIEnv*, jclass);
-
-JNIEXPORT jlong JNICALL Java_org_opencv_highgui_VideoCapture_n_1VideoCapture__
-  (JNIEnv* env, jclass c)
-{
-    return Java_org_opencv_highgui_VideoCapture_VideoCapture_10(env, c);
-}
-
-
-JNIEXPORT jlong JNICALL Java_org_opencv_highgui_VideoCapture_n_1VideoCapture__I
-  (JNIEnv* env, jclass c, jint device);
-
-JNIEXPORT jlong JNICALL Java_org_opencv_highgui_VideoCapture_VideoCapture_12 (JNIEnv*, jclass, jint);
-
-JNIEXPORT jlong JNICALL Java_org_opencv_highgui_VideoCapture_n_1VideoCapture__I
-  (JNIEnv* env, jclass c, jint device)
-{
-    return Java_org_opencv_highgui_VideoCapture_VideoCapture_12(env, c, device);
-}
-
-
-JNIEXPORT jdouble JNICALL Java_org_opencv_highgui_VideoCapture_n_1get
-  (JNIEnv* env, jclass c, jlong self, jint propId);
-
-JNIEXPORT jdouble JNICALL Java_org_opencv_highgui_VideoCapture_get_10 (JNIEnv*, jclass, jlong, jint);
-
-JNIEXPORT jdouble JNICALL Java_org_opencv_highgui_VideoCapture_n_1get
-  (JNIEnv* env, jclass c, jlong self, jint propId)
-{
-    return Java_org_opencv_highgui_VideoCapture_get_10(env, c, self, propId);
-}
-
-
-JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1grab
-  (JNIEnv* env, jclass c, jlong self);
-
-JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_grab_10 (JNIEnv*, jclass, jlong);
-
-JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1grab
-  (JNIEnv* env, jclass c, jlong self)
-{
-    return Java_org_opencv_highgui_VideoCapture_grab_10(env, c, self);
-}
-
-
-JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1isOpened
-  (JNIEnv* env, jclass c, jlong self);
-
-JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_isOpened_10 (JNIEnv*, jclass, jlong);
-
-JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1isOpened
-  (JNIEnv* env, jclass c, jlong self)
-{
-    return Java_org_opencv_highgui_VideoCapture_isOpened_10(env, c, self);
-}
-
-
-JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1open__JI
-  (JNIEnv* env, jclass c, jlong self, jint device);
-
-JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_open_11 (JNIEnv*, jclass, jlong, jint);
-
-JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1open__JI
-  (JNIEnv* env, jclass c, jlong self, jint device)
-{
-    return Java_org_opencv_highgui_VideoCapture_open_11(env, c, self, device);
-}
-
-
-JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1read
-  (JNIEnv* env, jclass c, jlong self, jlong image_nativeObj);
-
-JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_read_10 (JNIEnv*, jclass, jlong, jlong);
-
-JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1read
-  (JNIEnv* env, jclass c, jlong self, jlong image_nativeObj)
-{
-    return Java_org_opencv_highgui_VideoCapture_read_10(env, c, self, image_nativeObj);
-}
-
-
-JNIEXPORT void JNICALL Java_org_opencv_highgui_VideoCapture_n_1release
-  (JNIEnv* env, jclass c, jlong self);
-
-JNIEXPORT void JNICALL Java_org_opencv_highgui_VideoCapture_release_10 (JNIEnv*, jclass, jlong);
-
-JNIEXPORT void JNICALL Java_org_opencv_highgui_VideoCapture_n_1release
-  (JNIEnv* env, jclass c, jlong self)
-{
-    Java_org_opencv_highgui_VideoCapture_release_10(env, c, self);
-}
-
-
-JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1retrieve__JJI
-  (JNIEnv* env, jclass c, jlong self, jlong image_nativeObj, jint channel);
-
-JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_retrieve_10 (JNIEnv*, jclass, jlong, jlong, jint);
-
-JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1retrieve__JJI
-  (JNIEnv* env, jclass c, jlong self, jlong image_nativeObj, jint channel)
-{
-    return Java_org_opencv_highgui_VideoCapture_retrieve_10(env, c, self, image_nativeObj, channel);
-}
-
-
-JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1retrieve__JJ
-  (JNIEnv* env, jclass c, jlong self, jlong image_nativeObj);
-
-JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_retrieve_11 (JNIEnv*, jclass, jlong, jlong);
-
-JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1retrieve__JJ
-  (JNIEnv* env, jclass c, jlong self, jlong image_nativeObj)
-{
-    return Java_org_opencv_highgui_VideoCapture_retrieve_11(env, c, self, image_nativeObj);
-}
-
-
-JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1set
-  (JNIEnv* env, jclass c, jlong self, jint propId, jdouble value);
-
-JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_set_10 (JNIEnv*, jclass, jlong, jint, jdouble);
-
-JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1set
-  (JNIEnv* env, jclass c, jlong self, jint propId, jdouble value)
-{
-    return Java_org_opencv_highgui_VideoCapture_set_10(env, c, self, propId, value);
-}
-
-
-JNIEXPORT jstring JNICALL Java_org_opencv_highgui_VideoCapture_n_1getSupportedPreviewSizes
-  (JNIEnv *env, jclass c, jlong self);
-
-JNIEXPORT jstring JNICALL Java_org_opencv_highgui_VideoCapture_getSupportedPreviewSizes_10
-  (JNIEnv *env, jclass, jlong self);
-
-JNIEXPORT jstring JNICALL Java_org_opencv_highgui_VideoCapture_n_1getSupportedPreviewSizes
-  (JNIEnv *env, jclass c, jlong self)
-{
-    return Java_org_opencv_highgui_VideoCapture_getSupportedPreviewSizes_10(env, c, self);
-}
-
-
-JNIEXPORT void JNICALL Java_org_opencv_highgui_VideoCapture_n_1delete
-  (JNIEnv *env, jclass c, jlong self);
-
-JNIEXPORT void JNICALL Java_org_opencv_highgui_VideoCapture_delete(JNIEnv*, jclass, jlong);
-
-JNIEXPORT void JNICALL Java_org_opencv_highgui_VideoCapture_n_1delete
-  (JNIEnv *env, jclass c, jlong self)
-{
-    Java_org_opencv_highgui_VideoCapture_delete(env, c, self);
-}
-
-
-} // extern "C"
-#endif // (CV_VERSION_EPOCH == 2) && (CV_VERSION_MAJOR == 4)
-#endif // HAVE_OPENCV_HIGHGUI

modules/java/generator/src/java/highgui+VideoCapture.java

+package org.opencv.highgui;
+
+import java.util.List;
+import java.util.LinkedList;
+
+import org.opencv.core.Mat;
+import org.opencv.core.Size;
+
+// C++: class VideoCapture
+//javadoc: VideoCapture
+public class VideoCapture {
+
+    protected final long nativeObj;
+
+    protected VideoCapture(long addr) {
+        nativeObj = addr;
+    }
+
+    //
+    // C++: VideoCapture::VideoCapture()
+    //
+
+    // javadoc: VideoCapture::VideoCapture()
+    public VideoCapture()
+    {
+
+        nativeObj = n_VideoCapture();
+
+        return;
+    }
+
+    //
+    // C++: VideoCapture::VideoCapture(int device)
+    //
+
+    // javadoc: VideoCapture::VideoCapture(device)
+    public VideoCapture(int device)
+    {
+
+        nativeObj = n_VideoCapture(device);
+
+        return;
+    }
+
+    //
+    // C++: double VideoCapture::get(int propId)
+    //
+
+/**
+ * Returns the specified "VideoCapture" property.
+ *
+ * Note: When querying a property that is not supported by the backend used by
+ * the "VideoCapture" class, value 0 is returned.
+ *
+ * @param propId property identifier; it can be one of the following:
+ *   * CV_CAP_PROP_FRAME_WIDTH width of the frames in the video stream.
+ *   * CV_CAP_PROP_FRAME_HEIGHT height of the frames in the video stream.
+ *
+ * @see <a href="http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html#videocapture-get">org.opencv.highgui.VideoCapture.get</a>
+ */
+    public double get(int propId)
+    {
+
+        double retVal = n_get(nativeObj, propId);
+
+        return retVal;
+    }
+
+    public List<Size> getSupportedPreviewSizes()
+    {
+        String[] sizes_str = n_getSupportedPreviewSizes(nativeObj).split(",");
+        List<Size> sizes = new LinkedList<Size>();
+
+        for (String str : sizes_str) {
+            String[] wh = str.split("x");
+            sizes.add(new Size(Double.parseDouble(wh[0]), Double.parseDouble(wh[1])));
+        }
+
+        return sizes;
+    }
+
+    //
+    // C++: bool VideoCapture::grab()
+    //
+
+    // javadoc: VideoCapture::grab()
+    public boolean grab()
+    {
+
+        boolean retVal = n_grab(nativeObj);
+
+        return retVal;
+    }
+
+    //
+    // C++: bool VideoCapture::isOpened()
+    //
+
+    // javadoc: VideoCapture::isOpened()
+    public boolean isOpened()
+    {
+
+        boolean retVal = n_isOpened(nativeObj);
+
+        return retVal;
+    }
+
+    //
+    // C++: bool VideoCapture::open(int device)
+    //
+
+    // javadoc: VideoCapture::open(device)
+    public boolean open(int device)
+    {
+
+        boolean retVal = n_open(nativeObj, device);
+
+        return retVal;
+    }
+
+    //
+    // C++: bool VideoCapture::read(Mat image)
+    //
+
+    // javadoc: VideoCapture::read(image)
+    public boolean read(Mat image)
+    {
+
+        boolean retVal = n_read(nativeObj, image.nativeObj);
+
+        return retVal;
+    }
+
+    //
+    // C++: void VideoCapture::release()
+    //
+
+    // javadoc: VideoCapture::release()
+    public void release()
+    {
+
+        n_release(nativeObj);
+
+        return;
+    }
+
+    //
+    // C++: bool VideoCapture::retrieve(Mat image, int channel = 0)
+    //
+
+    // javadoc: VideoCapture::retrieve(image, channel)
+    public boolean retrieve(Mat image, int channel)
+    {
+
+        boolean retVal = n_retrieve(nativeObj, image.nativeObj, channel);
+
+        return retVal;
+    }
+
+    // javadoc: VideoCapture::retrieve(image)
+    public boolean retrieve(Mat image)
+    {
+
+        boolean retVal = n_retrieve(nativeObj, image.nativeObj);
+
+        return retVal;
+    }
+
+    //
+    // C++: bool VideoCapture::set(int propId, double value)
+    //
+
+/**
+ * Sets a property in the "VideoCapture".
+ *
+ * @param propId property identifier; it can be one of the following:
+ *   * CV_CAP_PROP_FRAME_WIDTH width of the frames in the video stream.
+ *   * CV_CAP_PROP_FRAME_HEIGHT height of the frames in the video stream.
+ * @param value value of the property.
+ *
+ * @see <a href="http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html#videocapture-set">org.opencv.highgui.VideoCapture.set</a>
+ */
+    public boolean set(int propId, double value)
+    {
+
+        boolean retVal = n_set(nativeObj, propId, value);
+
+        return retVal;
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        n_delete(nativeObj);
+        super.finalize();
+    }
+
+    // C++: VideoCapture::VideoCapture()
+    private static native long n_VideoCapture();
+
+    // C++: VideoCapture::VideoCapture(string filename)
+    private static native long n_VideoCapture(java.lang.String filename);
+
+    // C++: VideoCapture::VideoCapture(int device)
+    private static native long n_VideoCapture(int device);
+
+    // C++: double VideoCapture::get(int propId)
+    private static native double n_get(long nativeObj, int propId);
+
+    // C++: bool VideoCapture::grab()
+    private static native boolean n_grab(long nativeObj);
+
+    // C++: bool VideoCapture::isOpened()
+    private static native boolean n_isOpened(long nativeObj);
+
+    // C++: bool VideoCapture::open(string filename)
+    private static native boolean n_open(long nativeObj, java.lang.String filename);
+
+    // C++: bool VideoCapture::open(int device)
+    private static native boolean n_open(long nativeObj, int device);
+
+    // C++: bool VideoCapture::read(Mat image)
+    private static native boolean n_read(long nativeObj, long image_nativeObj);
+
+    // C++: void VideoCapture::release()
+    private static native void n_release(long nativeObj);
+
+    // C++: bool VideoCapture::retrieve(Mat image, int channel = 0)
+    private static native boolean n_retrieve(long nativeObj, long image_nativeObj, int channel);
+
+    private static native boolean n_retrieve(long nativeObj, long image_nativeObj);
+
+    // C++: bool VideoCapture::set(int propId, double value)
+    private static native boolean n_set(long nativeObj, int propId, double value);
+
+    private static native String n_getSupportedPreviewSizes(long nativeObj);
+
+    // native support for java finalize()
+    private static native void n_delete(long nativeObj);
+
+}