Merge pull request #476 from apavlenko:eclipse_import_fix

DeleteLocalRef calls for jclass objects added.

3rdparty/libjasper/CMakeLists.txt

@@ -24,6 +24,7 @@ if(WIN32 AND NOT MINGW)
 endif(WIN32 AND NOT MINGW)
 
 ocv_warnings_disable(CMAKE_C_FLAGS -Wno-implicit-function-declaration -Wno-uninitialized -Wmissing-prototypes -Wmissing-declarations -Wunused -Wshadow -Wsign-compare)
+ocv_warnings_disable(CMAKE_C_FLAGS -Wunused-parameter) # clang
 ocv_warnings_disable(CMAKE_C_FLAGS /wd4013 /wd4018 /wd4101 /wd4244 /wd4267 /wd4715) # vs2005
 
 if(UNIX)

3rdparty/libjpeg/CMakeLists.txt

@@ -26,6 +26,7 @@ if(CMAKE_COMPILER_IS_GNUCXX)
 endif()
 
 ocv_warnings_disable(CMAKE_C_FLAGS -Wcast-align -Wshadow -Wunused)
+ocv_warnings_disable(CMAKE_C_FLAGS -Wunused-parameter) # clang
 
 set_target_properties(${JPEG_LIBRARY}
   PROPERTIES OUTPUT_NAME ${JPEG_LIBRARY}

3rdparty/libtiff/CMakeLists.txt

@@ -89,6 +89,7 @@ endif(WIN32)
 
 ocv_warnings_disable(CMAKE_C_FLAGS -Wno-unused-but-set-variable -Wmissing-prototypes -Wmissing-declarations -Wundef -Wunused -Wsign-compare
                                    -Wcast-align -Wshadow -Wno-maybe-uninitialized -Wno-pointer-to-int-cast -Wno-int-to-pointer-cast)
+ocv_warnings_disable(CMAKE_C_FLAGS -Wunused-parameter) # clang
 ocv_warnings_disable(CMAKE_CXX_FLAGS -Wmissing-declarations -Wunused-parameter)
 ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4018 /wd4100 /wd4127 /wd4311 /wd4701 /wd4706) # vs2005
 ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4244) # vs2008

3rdparty/tbb/CMakeLists.txt

@@ -1,44 +1,53 @@
-#build TBB for Android from source
-if(NOT ANDROID)
-  message(FATAL_ERROR "The script is designed for Android only!")
-endif()
-
+#Cross compile TBB from source
 project(tbb)
 
-# 4.1 - works fine
-set(tbb_ver "tbb41_20120718oss")
-set(tbb_url "http://threadingbuildingblocks.org/uploads/77/188/4.1/tbb41_20120718oss_src.tgz")
-set(tbb_md5 "31b9ec300f3d09da2504d5d882788dd4")
+# 4.1 update 2 - works fine
+set(tbb_ver "tbb41_20130116oss")
+set(tbb_url "http://threadingbuildingblocks.org/sites/default/files/software_releases/source/tbb41_20130116oss_src.tgz")
+set(tbb_md5 "3809790e1001a1b32d59c9fee590ee85")
 set(tbb_version_file "version_string.ver")
+ocv_warnings_disable(CMAKE_CXX_FLAGS -Wshadow)
+
+# 4.1 update 1 - works fine
+#set(tbb_ver "tbb41_20121003oss")
+#set(tbb_url "http://threadingbuildingblocks.org/sites/default/files/software_releases/source/tbb41_20121003oss_src.tgz")
+#set(tbb_md5 "2a684fefb855d2d0318d1ef09afa75ff")
+#set(tbb_version_file "version_string.ver")
+
+# 4.1 - works fine
+#set(tbb_ver "tbb41_20120718oss")
+#set(tbb_url "http://threadingbuildingblocks.org/sites/default/files/software_releases/source/tbb41_20120718oss_src.tgz")
+#set(tbb_md5 "31b9ec300f3d09da2504d5d882788dd4")
+#set(tbb_version_file "version_string.ver")
 
 # 4.0 update 5 - works fine
 #set(tbb_ver "tbb40_20120613oss")
-#set(tbb_url "http://threadingbuildingblocks.org/uploads/77/187/4.0%20update%205/tbb40_20120613oss_src.tgz")
+#set(tbb_url "http://threadingbuildingblocks.org/sites/default/files/software_releases/source/tbb40_20120613oss_src.tgz")
 #set(tbb_md5 "da01ed74944ec5950cfae3476901a172")
 #set(tbb_version_file "version_string.ver")
 
 # 4.0 update 4 - works fine
 #set(tbb_ver "tbb40_20120408oss")
-#set(tbb_url "http://threadingbuildingblocks.org/uploads/77/185/4.0%20update%204/tbb40_20120408oss_src.tgz")
+#set(tbb_url "http://threadingbuildingblocks.org/sites/default/files/software_releases/source/tbb40_20120408oss_src.tgz")
 #set(tbb_md5 "734b356da7fe0ed308741f3e6018251e")
 #set(tbb_version_file "version_string.ver")
 
 # 4.0 update 3 - build broken
 #set(tbb_ver "tbb40_20120201oss")
-#set(tbb_url "http://threadingbuildingblocks.org/uploads/77/182/4.0%20update%203/tbb40_20120201oss_src.tgz")
+#set(tbb_url "http://threadingbuildingblocks.org/sites/default/files/software_releases/source/tbb40_20120201oss_src.tgz")
 #set(tbb_md5 "4669e7d4adee018de7a7b8b972987218")
 #set(tbb_version_file "version_string.tmp")
 
 # 4.0 update 2 - works fine
 #set(tbb_ver "tbb40_20111130oss")
-#set(tbb_url "http://threadingbuildingblocks.org/uploads/77/180/4.0%20update%202/tbb40_20111130oss_src.tgz")
+#set(tbb_url "http://threadingbuildingblocks.org/sites/default/files/software_releases/source/tbb40_20111130oss_src.tgz")
 #set(tbb_md5 "1e6926b21e865e79772119cd44fc3ad8")
 #set(tbb_version_file "version_string.tmp")
 #set(tbb_need_GENERIC_DWORD_LOAD_STORE TRUE)
 
 # 4.0 update 1 - works fine
 #set(tbb_ver "tbb40_20111003oss")
-#set(tbb_url "http://threadingbuildingblocks.org/uploads/77/177/4.0%20update%201/tbb40_20111003oss_src.tgz")
+#set(tbb_url "http://threadingbuildingblocks.org/sites/default/files/software_releases/source/tbb40_20111003oss_src.tgz")
 #set(tbb_md5 "7b5d94eb35a563b29ef402e0fd8f15c9")
 #set(tbb_version_file "version_string.tmp")
 #set(tbb_need_GENERIC_DWORD_LOAD_STORE TRUE)
@@ -115,28 +124,43 @@ list(APPEND lib_srcs "${tbb_src_dir}/src/rml/client/rml_tbb.cpp")
 
 add_definitions(-D__TBB_DYNAMIC_LOAD_ENABLED=0         #required
                 -D__TBB_BUILD=1                        #required
-                -D__TBB_SURVIVE_THREAD_SWITCH=0        #no cilk on Android ?
-                -DUSE_PTHREAD                          #required
-                -DTBB_USE_GCC_BUILTINS=1               #required
+                -D__TBB_SURVIVE_THREAD_SWITCH=0        #no cilk support
+                -DUSE_PTHREAD                          #required for Unix
+                -DTBB_USE_GCC_BUILTINS=1               #required for ARM GCC
                 -DTBB_USE_DEBUG=0                      #just to be sure
                 -DTBB_NO_LEGACY=1                      #don't need backward compatibility
                 -DDO_ITT_NOTIFY=0                      #it seems that we don't need these notifications
                )
 
+if(ANDROID_COMPILER_IS_CLANG)
+  add_definitions(-D__TBB_GCC_BUILTIN_ATOMICS_PRESENT=1)
+  ocv_warnings_disable(CMAKE_CXX_FLAGS -Wmissing-prototypes)
+endif()
+
 if(tbb_need_GENERIC_DWORD_LOAD_STORE)
   #needed by TBB 4.0 update 1,2; fixed in TBB 4.0 update 3 but it has 2 new problems
   add_definitions(-D__TBB_USE_GENERIC_DWORD_LOAD_STORE=1)
   set(tbb_need_GENERIC_DWORD_LOAD_STORE ON PARENT_SCOPE)
 endif()
 
-add_library(tbb STATIC ${lib_srcs} ${lib_hdrs} "${CMAKE_CURRENT_SOURCE_DIR}/android_additional.h" "${CMAKE_CURRENT_SOURCE_DIR}/${tbb_version_file}")
+set(TBB_SOURCE_FILES ${lib_srcs} ${lib_hdrs})
+
+if (${CMAKE_SYSTEM_PROCESSOR} MATCHES "arm")
+  if (NOT ANDROID)
+    set(TBB_SOURCE_FILES ${TBB_SOURCE_FILES} "${CMAKE_CURRENT_SOURCE_DIR}/arm_linux_stub.cpp")
+  endif()
+  set(TBB_SOURCE_FILES ${TBB_SOURCE_FILES} "${CMAKE_CURRENT_SOURCE_DIR}/android_additional.h")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -include \"${CMAKE_CURRENT_SOURCE_DIR}/android_additional.h\"")
+endif()
+
+set(TBB_SOURCE_FILES ${TBB_SOURCE_FILES} "${CMAKE_CURRENT_SOURCE_DIR}/${tbb_version_file}")
+
+add_library(tbb ${TBB_SOURCE_FILES})
 target_link_libraries(tbb c m dl)
 
 ocv_warnings_disable(CMAKE_CXX_FLAGS -Wundef -Wmissing-declarations)
 string(REPLACE "-Werror=non-virtual-dtor" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -include \"${CMAKE_CURRENT_SOURCE_DIR}/android_additional.h\"")
-
 set_target_properties(tbb
   PROPERTIES OUTPUT_NAME tbb
   DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
@@ -153,4 +177,3 @@ endif()
 
 # get TBB version
 ocv_parse_header("${tbb_src_dir}/include/tbb/tbb_stddef.h" TBB_VERSION_LINES TBB_VERSION_MAJOR TBB_VERSION_MINOR TBB_INTERFACE_VERSION CACHE)
-

3rdparty/tbb/arm_linux_stub.cpp

@@ -0,0 +1,10 @@
+#include "tbb/tbb_misc.h"
+
+namespace tbb {
+namespace internal {
+
+void affinity_helper::protect_affinity_mask() {}
+affinity_helper::~affinity_helper() {}
+
+}
+}

CMakeLists.txt

@@ -110,14 +110,15 @@ endif()
 
 # Optional 3rd party components
 # ===================================================
-OCV_OPTION(WITH_1394           "Include IEEE1394 support"                    ON   IF (UNIX AND NOT ANDROID AND NOT IOS) )
+OCV_OPTION(WITH_1394           "Include IEEE1394 support"                    ON   IF (UNIX AND NOT ANDROID AND NOT IOS AND NOT CARMA) )
 OCV_OPTION(WITH_AVFOUNDATION   "Use AVFoundation for Video I/O"              ON   IF IOS)
 OCV_OPTION(WITH_CARBON         "Use Carbon for UI instead of Cocoa"          OFF  IF APPLE )
-OCV_OPTION(WITH_CUBLAS         "Include NVidia Cuda Basic Linear Algebra Subprograms (BLAS) library support" OFF IF (CMAKE_VERSION VERSION_GREATER "2.8" AND NOT ANDROID AND NOT IOS) )
 OCV_OPTION(WITH_CUDA           "Include NVidia Cuda Runtime support"         ON   IF (CMAKE_VERSION VERSION_GREATER "2.8" AND NOT ANDROID AND NOT IOS) )
 OCV_OPTION(WITH_CUFFT          "Include NVidia Cuda Fast Fourier Transform (FFT) library support"            ON  IF (CMAKE_VERSION VERSION_GREATER "2.8" AND NOT ANDROID AND NOT IOS) )
+OCV_OPTION(WITH_CUBLAS         "Include NVidia Cuda Basic Linear Algebra Subprograms (BLAS) library support" OFF IF (CMAKE_VERSION VERSION_GREATER "2.8" AND NOT ANDROID AND NOT IOS) )
+OCV_OPTION(WITH_NVCUVID        "Include NVidia Video Decoding library support"                               OFF IF (CMAKE_VERSION VERSION_GREATER "2.8" AND NOT ANDROID AND NOT IOS AND NOT APPLE) )
 OCV_OPTION(WITH_EIGEN          "Include Eigen2/Eigen3 support"               ON)
-OCV_OPTION(WITH_FFMPEG         "Include FFMPEG support"                      ON   IF (NOT ANDROID AND NOT IOS) )
+OCV_OPTION(WITH_FFMPEG         "Include FFMPEG support"                      ON   IF (NOT ANDROID AND NOT IOS))
 OCV_OPTION(WITH_GSTREAMER      "Include Gstreamer support"                   ON   IF (UNIX AND NOT APPLE AND NOT ANDROID) )
 OCV_OPTION(WITH_GTK            "Include GTK support"                         ON   IF (UNIX AND NOT APPLE AND NOT ANDROID) )
 OCV_OPTION(WITH_IMAGEIO        "ImageIO support for OS X"                    OFF  IF APPLE)
@@ -136,18 +137,19 @@ OCV_OPTION(WITH_TBB            "Include Intel TBB support"                   OFF
 OCV_OPTION(WITH_CSTRIPES       "Include C= support"                          OFF  IF WIN32 )
 OCV_OPTION(WITH_TIFF           "Include TIFF support"                        ON   IF (NOT IOS) )
 OCV_OPTION(WITH_UNICAP         "Include Unicap support (GPL)"                OFF  IF (UNIX AND NOT APPLE AND NOT ANDROID) )
-OCV_OPTION(WITH_V4L            "Include Video 4 Linux support"               ON   IF (UNIX AND NOT APPLE AND NOT ANDROID) )
+OCV_OPTION(WITH_V4L            "Include Video 4 Linux support"               ON   IF (UNIX AND NOT ANDROID) )
 OCV_OPTION(WITH_VIDEOINPUT     "Build HighGUI with DirectShow support"       ON   IF WIN32 )
 OCV_OPTION(WITH_XIMEA          "Include XIMEA cameras support"               OFF  IF (NOT ANDROID AND NOT APPLE) )
 OCV_OPTION(WITH_XINE           "Include Xine support (GPL)"                  OFF  IF (UNIX AND NOT APPLE AND NOT ANDROID) )
-OCV_OPTION(WITH_OPENCL         "Include OpenCL Runtime support"              OFF  IF (NOT ANDROID AND NOT IOS) )
-OCV_OPTION(WITH_OPENCLAMDFFT   "Include AMD OpenCL FFT library support"      OFF  IF (NOT ANDROID AND NOT IOS) )
-OCV_OPTION(WITH_OPENCLAMDBLAS  "Include AMD OpenCL BLAS library support"     OFF  IF (NOT ANDROID AND NOT IOS) )
+OCV_OPTION(WITH_OPENCL         "Include OpenCL Runtime support"              OFF  IF (NOT ANDROID AND NOT IOS AND NOT CARMA) )
+OCV_OPTION(WITH_OPENCLAMDFFT   "Include AMD OpenCL FFT library support"      OFF  IF (NOT ANDROID AND NOT IOS AND NOT CARMA) )
+OCV_OPTION(WITH_OPENCLAMDBLAS  "Include AMD OpenCL BLAS library support"     OFF  IF (NOT ANDROID AND NOT IOS AND NOT CARMA) )
 
 
 # OpenCV build components
 # ===================================================
 OCV_OPTION(BUILD_SHARED_LIBS        "Build shared libraries (.dll/.so) instead of static ones (.lib/.a)" NOT (ANDROID OR IOS) )
+OCV_OPTION(BUILD_opencv_apps        "Build utility applications (used for example to train classifiers)" (NOT ANDROID) IF (NOT IOS) )
 OCV_OPTION(BUILD_ANDROID_EXAMPLES   "Build examples for Android platform"         ON  IF ANDROID )
 OCV_OPTION(BUILD_DOCS               "Create build rules for OpenCV Documentation" ON )
 OCV_OPTION(BUILD_EXAMPLES           "Build all examples"                          OFF )
@@ -156,18 +158,18 @@ OCV_OPTION(BUILD_PERF_TESTS         "Build performance tests"
 OCV_OPTION(BUILD_TESTS              "Build accuracy & regression tests"           ON  IF (NOT IOS) )
 OCV_OPTION(BUILD_WITH_DEBUG_INFO    "Include debug info into debug libs (not MSCV only)" ON )
 OCV_OPTION(BUILD_WITH_STATIC_CRT    "Enables use of staticaly linked CRT for staticaly linked OpenCV" ON IF MSVC )
-OCV_OPTION(BUILD_FAT_JAVA_LIB       "Create fat java wrapper containing the whole OpenCV library" ON IF ANDROID AND NOT BUILD_SHARED_LIBS AND CMAKE_COMPILER_IS_GNUCXX )
-OCV_OPTION(BUILD_ANDROID_SERVICE    "Build OpenCV Manager for Google Play" OFF IF ANDROID AND ANDROID_USE_STLPORT AND ANDROID_SOURCE_TREE )
+OCV_OPTION(BUILD_FAT_JAVA_LIB       "Create fat java wrapper containing the whole OpenCV library" ON IF NOT BUILD_SHARED_LIBS AND CMAKE_COMPILER_IS_GNUCXX )
+OCV_OPTION(BUILD_ANDROID_SERVICE    "Build OpenCV Manager for Google Play" OFF IF ANDROID AND ANDROID_SOURCE_TREE )
 OCV_OPTION(BUILD_ANDROID_PACKAGE    "Build platform-specific package for Google Play" OFF IF ANDROID )
 
 # 3rd party libs
-OCV_OPTION(BUILD_ZLIB               "Build zlib from source"         WIN32 OR APPLE )
-OCV_OPTION(BUILD_TIFF               "Build libtiff from source"      WIN32 OR ANDROID OR APPLE )
-OCV_OPTION(BUILD_JASPER             "Build libjasper from source"    WIN32 OR ANDROID OR APPLE )
-OCV_OPTION(BUILD_JPEG               "Build libjpeg from source"      WIN32 OR ANDROID OR APPLE )
-OCV_OPTION(BUILD_PNG                "Build libpng from source"       WIN32 OR ANDROID OR APPLE )
-OCV_OPTION(BUILD_OPENEXR            "Build openexr from source"      WIN32 OR ANDROID OR APPLE )
-
+OCV_OPTION(BUILD_ZLIB               "Build zlib from source"             WIN32 OR APPLE OR CARMA )
+OCV_OPTION(BUILD_TIFF               "Build libtiff from source"          WIN32 OR ANDROID OR APPLE OR CARMA )
+OCV_OPTION(BUILD_JASPER             "Build libjasper from source"        WIN32 OR ANDROID OR APPLE OR CARMA )
+OCV_OPTION(BUILD_JPEG               "Build libjpeg from source"          WIN32 OR ANDROID OR APPLE OR CARMA )
+OCV_OPTION(BUILD_PNG                "Build libpng from source"           WIN32 OR ANDROID OR APPLE OR CARMA )
+OCV_OPTION(BUILD_OPENEXR            "Build openexr from source"          WIN32 OR ANDROID OR APPLE OR CARMA )
+OCV_OPTION(BUILD_TBB                "Download and build TBB from source" ANDROID IF CMAKE_COMPILER_IS_GNUCXX )
 
 # OpenCV installation options
 # ===================================================
@@ -415,10 +417,10 @@ if(WITH_OPENCL)
   if(OPENCL_FOUND)
     set(HAVE_OPENCL 1)
   endif()
-  if(WITH_OPENCLAMDFFT)
+  if(WITH_OPENCLAMDFFT AND CLAMDFFT_INCLUDE_DIR)
     set(HAVE_CLAMDFFT 1)
   endif()
-  if(WITH_OPENCLAMDBLAS)
+  if(WITH_OPENCLAMDBLAS AND CLAMDBLAS_INCLUDE_DIR)
     set(HAVE_CLAMDBLAS 1)
   endif()
 endif()
@@ -452,14 +454,16 @@ add_subdirectory(doc)
 add_subdirectory(data)
 
 # extra applications
-add_subdirectory(apps)
+if(BUILD_opencv_apps)
+  add_subdirectory(apps)
+endif()
 
 # examples
 if(BUILD_EXAMPLES OR BUILD_ANDROID_EXAMPLES OR INSTALL_PYTHON_EXAMPLES)
   add_subdirectory(samples)
 endif()
 
-if(BUILD_ANDROID_SERVICE)
+if(ANDROID)
   add_subdirectory(android/service)
 endif()
 
@@ -467,6 +471,10 @@ if(BUILD_ANDROID_PACKAGE)
   add_subdirectory(android/package)
 endif()
 
+if (ANDROID)
+  add_subdirectory(android/libinfo)
+endif()
+
 # ----------------------------------------------------------------------------
 # Finalization: generate configuration-based files
 # ----------------------------------------------------------------------------
@@ -489,7 +497,7 @@ include(cmake/OpenCVGenConfig.cmake)
 # Summary:
 # ----------------------------------------------------------------------------
 status("")
-status("General configuration for OpenCV ${OPENCV_VERSION}-rc =====================================")
+status("General configuration for OpenCV ${OPENCV_VERSION} =====================================")
 if(OPENCV_VCSVERSION)
   status("  Version control:" ${OPENCV_VCSVERSION})
 endif()
@@ -547,7 +555,11 @@ foreach(m ${OPENCV_MODULES_DISABLED_AUTO})
       list(APPEND __mdeps ${d})
     endif()
   endforeach()
-  list(APPEND OPENCV_MODULES_DISABLED_AUTO_ST "${m}(deps: ${__mdeps})")
+  if(__mdeps)
+    list(APPEND OPENCV_MODULES_DISABLED_AUTO_ST "${m}(deps: ${__mdeps})")
+  else()
+    list(APPEND OPENCV_MODULES_DISABLED_AUTO_ST "${m}")
+  endif()
 endforeach()
 string(REPLACE "opencv_" "" OPENCV_MODULES_DISABLED_AUTO_ST  "${OPENCV_MODULES_DISABLED_AUTO_ST}")
 
@@ -561,6 +573,7 @@ if(ANDROID)
   status("")
   status("  Android: ")
   status("    Android ABI:" ${ANDROID_ABI})
+  status("    STL type:" ${ANDROID_STL})
   status("    Native API level:" android-${ANDROID_NATIVE_API_LEVEL})
   status("    SDK target:" "${ANDROID_SDK_TARGET}")
   if(BUILD_WITH_ANDROID_NDK)
@@ -715,11 +728,13 @@ if(DEFINED WITH_V4L)
   endif()
   if(HAVE_CAMV4L2)
     set(HAVE_CAMV4L2_STR "YES")
+  elseif(HAVE_VIDEOIO)
+    set(HAVE_CAMV4L2_STR "YES(videoio)")
   else()
     set(HAVE_CAMV4L2_STR "NO")
   endif()
   status("    V4L/V4L2:"       HAVE_LIBV4L         THEN "Using libv4l (ver ${ALIASOF_libv4l1_VERSION})"
-                                                                                                   ELSE "${HAVE_CAMV4L_STR}/${HAVE_CAMV4L2_STR}")
+                                                   ELSE "${HAVE_CAMV4L_STR}/${HAVE_CAMV4L2_STR}")
 endif(DEFINED WITH_V4L)
 
 if(DEFINED WITH_VIDEOINPUT)
@@ -767,8 +782,9 @@ if(HAVE_CUDA)
   status("")
   status("  NVIDIA CUDA")
 
-  status("    Use CUFFT:"            HAVE_CUFFT  THEN YES ELSE NO)
-  status("    Use CUBLAS:"           HAVE_CUBLAS THEN YES ELSE NO)
+  status("    Use CUFFT:"            HAVE_CUFFT   THEN YES ELSE NO)
+  status("    Use CUBLAS:"           HAVE_CUBLAS  THEN YES ELSE NO)
+  status("    USE NVCUVID:"          HAVE_NVCUVID THEN YES ELSE NO)
   status("    NVIDIA GPU arch:"      ${OPENCV_CUDA_ARCH_BIN})
   status("    NVIDIA PTX archs:"     ${OPENCV_CUDA_ARCH_PTX})
   status("    Use fast math:"        CUDA_FAST_MATH THEN YES ELSE NO)

android/README.android

@@ -1 +1 @@
-See http://code.opencv.org/projects/opencv/wiki/OpenCV4Android
+See http://opencv.org/android

android/android.toolchain.cmake

@@ -1,7 +1,37 @@
+# Copyright (c) 2010-2011, Ethan Rublee
+# Copyright (c) 2011-2012, Andrey Kamaev
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1.  Redistributions of source code must retain the above copyright notice,
+#     this list of conditions and the following disclaimer.
+#
+# 2.  Redistributions in binary form must reproduce the above copyright notice,
+#     this list of conditions and the following disclaimer in the documentation
+#     and/or other materials provided with the distribution.
+#
+# 3.  The name of the copyright holders may be used to endorse or promote
+#     products derived from this software without specific prior written
+#     permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
 # ------------------------------------------------------------------------------
 #  Android CMake toolchain file, for use with the Android NDK r5-r8
 #  Requires cmake 2.6.3 or newer (2.8.5 or newer is recommended).
-#  See home page: http://code.google.com/p/android-cmake/
+#  See home page: https://github.com/taka-no-me/android-cmake
 #
 #  The file is mantained by the OpenCV project. The latest version can be get at
 #  http://code.opencv.org/projects/opencv/repository/revisions/master/changes/android/android.toolchain.cmake
@@ -64,6 +94,20 @@
 #    ANDROID_NATIVE_API_LEVEL=android-8 - level of Android API compile for.
 #      Option is read-only when standalone toolchain is used.
 #
+#    ANDROID_TOOLCHAIN_NAME=arm-linux-androideabi-4.6 - the name of compiler
+#      toolchain to be used. The list of possible values depends on the NDK
+#      version. For NDK r8c the possible values are:
+#
+#        * arm-linux-androideabi-4.4.3
+#        * arm-linux-androideabi-4.6
+#        * arm-linux-androideabi-clang3.1
+#        * mipsel-linux-android-4.4.3
+#        * mipsel-linux-android-4.6
+#        * mipsel-linux-android-clang3.1
+#        * x86-4.4.3
+#        * x86-4.6
+#        * x86-clang3.1
+#
 #    ANDROID_FORCE_ARM_BUILD=OFF - set ON to generate 32-bit ARM instructions
 #      instead of Thumb. Is not available for "x86" (inapplicable) and
 #      "armeabi-v6 with VFP" (is forced to be ON) ABIs.
@@ -147,13 +191,9 @@
 #    under the ${LIBRARY_OUTPUT_PATH_ROOT}/libs/${ANDROID_NDK_ABI_NAME}
 #    (depending on the target ABI). This is convenient for Android packaging.
 #
-#  Authors:
-#    Ethan Rublee ethan.ruble@gmail.com
-#    Andrey Kamaev andrey.kamaev@itseez.com
-#
 #  Change Log:
 #   - initial version December 2010
-#   - modified April 2011
+#   - April 2011
 #     [+] added possibility to build with NDK (without standalone toolchain)
 #     [+] support cross-compilation on Windows (native, no cygwin support)
 #     [+] added compiler option to force "char" type to be signed
@@ -164,13 +204,13 @@
 #     [+] EXECUTABLE_OUTPUT_PATH is set by toolchain (required on Windows)
 #     [~] Fixed bug with ANDROID_API_LEVEL variable
 #     [~] turn off SWIG search if it is not found first time
-#   - modified May 2011
+#   - May 2011
 #     [~] ANDROID_LEVEL is renamed to ANDROID_API_LEVEL
 #     [+] ANDROID_API_LEVEL is detected by toolchain if not specified
 #     [~] added guard to prevent changing of output directories on the first
 #         cmake pass
 #     [~] toolchain exits with error if ARM_TARGET is not recognized
-#   - modified June 2011
+#   - June 2011
 #     [~] default NDK path is updated for version r5c
 #     [+] variable CMAKE_SYSTEM_PROCESSOR is set based on ARM_TARGET
 #     [~] toolchain install directory is added to linker paths
@@ -178,13 +218,13 @@
 #     [+] added macro find_host_package, find_host_program to search
 #         packages/programs on the host system
 #     [~] fixed path to STL library
-#   - modified July 2011
+#   - July 2011
 #     [~] fixed options caching
 #     [~] search for all supported NDK versions
 #     [~] allowed spaces in NDK path
-#   - modified September 2011
+#   - September 2011
 #     [~] updated for NDK r6b
-#   - modified November 2011
+#   - November 2011
 #     [*] rewritten for NDK r7
 #     [+] x86 toolchain support (experimental)
 #     [+] added "armeabi-v6 with VFP" ABI for ARMv6 processors.
@@ -197,37 +237,37 @@
 #     [~] ARM_TARGET is renamed to ANDROID_ABI
 #     [~] ARMEABI_NDK_NAME is renamed to ANDROID_NDK_ABI_NAME
 #     [~] ANDROID_API_LEVEL is renamed to ANDROID_NATIVE_API_LEVEL
-#   - modified January 2012
+#   - January 2012
 #     [+] added stlport_static support (experimental)
 #     [+] added special check for cygwin
 #     [+] filtered out hidden files (starting with .) while globbing inside NDK
 #     [+] automatically applied GLESv2 linkage fix for NDK revisions 5-6
 #     [+] added ANDROID_GET_ABI_RAWNAME to get NDK ABI names by CMake flags
-#   - modified February 2012
+#   - February 2012
 #     [+] updated for NDK r7b
 #     [~] fixed cmake try_compile() command
 #     [~] Fix for missing install_name_tool on OS X
-#   - modified March 2012
+#   - March 2012
 #     [~] fixed incorrect C compiler flags
 #     [~] fixed CMAKE_SYSTEM_PROCESSOR change on ANDROID_ABI change
 #     [+] improved toolchain loading speed
 #     [+] added assembler language support (.S)
 #     [+] allowed preset search paths and extra search suffixes
-#   - modified April 2012
+#   - April 2012
 #     [+] updated for NDK r7c
 #     [~] fixed most of problems with compiler/linker flags and caching
 #     [+] added option ANDROID_FUNCTION_LEVEL_LINKING
-#   - modified May 2012
+#   - May 2012
 #     [+] updated for NDK r8
 #     [+] added mips architecture support
-#   - modified August 2012
+#   - August 2012
 #     [+] updated for NDK r8b
 #     [~] all intermediate files generated by toolchain are moved to CMakeFiles
 #     [~] libstdc++ and libsupc are removed from explicit link libraries
 #     [+] added CCache support (via NDK_CCACHE environment or cmake variable)
 #     [+] added gold linker support for NDK r8b
 #     [~] fixed mips linker flags for NDK r8b
-#   - modified September 2012
+#   - September 2012
 #     [+] added NDK release name detection (see ANDROID_NDK_RELEASE)
 #     [+] added support for all C++ runtimes from NDK
 #         (system, gabi++, stlport, gnustl)
@@ -235,8 +275,14 @@
 #     [~] use gold linker as default if available (NDK r8b)
 #     [~] globally turned off rpath
 #     [~] compiler options are aligned with NDK r8b
-#   - modified October 2012
+#   - October 2012
 #     [~] fixed C++ linking: explicitly link with math library (OpenCV #2426)
+#   - November 2012
+#     [+] updated for NDK r8c
+#     [+] added support for clang compiler
+#   - December 2012
+#     [~] fixed ccache full path search
+#     [+] updated for NDK r8d
 # ------------------------------------------------------------------------------
 
 cmake_minimum_required( VERSION 2.6.3 )
@@ -259,7 +305,7 @@ set( CMAKE_SYSTEM_VERSION 1 )
 # rpath makes low sence for Android
 set( CMAKE_SKIP_RPATH TRUE CACHE BOOL "If set, runtime paths are not added when using shared libraries." )
 
-set( ANDROID_SUPPORTED_NDK_VERSIONS ${ANDROID_EXTRA_NDK_VERSIONS} -r8b -r8 -r7c -r7b -r7 -r6b -r6 -r5c -r5b -r5 "" )
+set( ANDROID_SUPPORTED_NDK_VERSIONS ${ANDROID_EXTRA_NDK_VERSIONS} -r8d -r8c -r8b -r8 -r7c -r7b -r7 -r6b -r6 -r5c -r5b -r5 "" )
 if(NOT DEFINED ANDROID_NDK_SEARCH_PATHS)
  if( CMAKE_HOST_WIN32 )
   file( TO_CMAKE_PATH "$ENV{PROGRAMFILES}" ANDROID_NDK_SEARCH_PATHS )
@@ -367,8 +413,8 @@ endmacro()
 
 macro( __DETECT_TOOLCHAIN_MACHINE_NAME _var _root )
  if( EXISTS "${_root}" )
-  file( GLOB __gccExePath "${_root}/bin/*-gcc${TOOL_OS_SUFFIX}" )
-  __LIST_FILTER( __gccExePath "bin/[.].*-gcc${TOOL_OS_SUFFIX}$" )
+  file( GLOB __gccExePath RELATIVE "${_root}/bin/" "${_root}/bin/*-gcc${TOOL_OS_SUFFIX}" )
+  __LIST_FILTER( __gccExePath "^[.].*" )
   list( LENGTH __gccExePath __gccExePathsCount )
   if( NOT __gccExePathsCount EQUAL 1  AND NOT _CMAKE_IN_TRY_COMPILE )
    message( WARNING "Could not determine machine name for compiler from ${_root}" )
@@ -506,55 +552,76 @@ if( BUILD_WITH_STANDALONE_TOOLCHAIN )
  elseif( __availableToolchainMachines MATCHES mipsel )
   set( __availableToolchainArchs "mipsel" )
  endif()
- if( ANDROID_COMPILER_VERSION )
-  # do not run gcc every time because it is relatevely expencive
-  set( __availableToolchainCompilerVersions "${ANDROID_COMPILER_VERSION}" )
- else()
-  execute_process( COMMAND "${ANDROID_STANDALONE_TOOLCHAIN}/bin/${__availableToolchainMachines}-gcc${TOOL_OS_SUFFIX}" --version
-   OUTPUT_VARIABLE __availableToolchainCompilerVersions OUTPUT_STRIP_TRAILING_WHITESPACE )
-  string( REGEX MATCH "[0-9]+[.][0-9]+([.][0-9]+)?" __availableToolchainCompilerVersions "${__availableToolchainCompilerVersions}" )
+ execute_process( COMMAND "${ANDROID_STANDALONE_TOOLCHAIN}/bin/${__availableToolchainMachines}-gcc${TOOL_OS_SUFFIX}" -dumpversion
+                  OUTPUT_VARIABLE __availableToolchainCompilerVersions OUTPUT_STRIP_TRAILING_WHITESPACE )
+ string( REGEX MATCH "[0-9]+[.][0-9]+([.][0-9]+)?" __availableToolchainCompilerVersions "${__availableToolchainCompilerVersions}" )
+ if( EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/bin/clang${TOOL_OS_SUFFIX}" )
+  list( APPEND __availableToolchains "standalone-clang" )
+  list( APPEND __availableToolchainMachines ${__availableToolchainMachines} )
+  list( APPEND __availableToolchainArchs ${__availableToolchainArchs} )
+  list( APPEND __availableToolchainCompilerVersions ${__availableToolchainCompilerVersions} )
  endif()
 endif()
 
+macro( __GLOB_NDK_TOOLCHAINS __availableToolchainsVar )
+ foreach( __toolchain ${${__availableToolchainsVar}} )
+  if( "${__toolchain}" MATCHES "-clang3[.][0-9]$" AND NOT EXISTS "${ANDROID_NDK}/toolchains/${__toolchain}/prebuilt/" )
+   string( REGEX REPLACE "-clang3[.][0-9]$" "-4.6" __gcc_toolchain "${__toolchain}" )
+  else()
+   set( __gcc_toolchain "${__toolchain}" )
+  endif()
+  __DETECT_TOOLCHAIN_MACHINE_NAME( __machine "${ANDROID_NDK}/toolchains/${__gcc_toolchain}/prebuilt/${ANDROID_NDK_HOST_SYSTEM_NAME}" )
+  if( __machine )
+   string( REGEX MATCH "[0-9]+[.][0-9]+([.][0-9]+)?$" __version "${__gcc_toolchain}" )
+   string( REGEX MATCH "^[^-]+" __arch "${__gcc_toolchain}" )
+   list( APPEND __availableToolchainMachines "${__machine}" )
+   list( APPEND __availableToolchainArchs "${__arch}" )
+   list( APPEND __availableToolchainCompilerVersions "${__version}" )
+  else()
+   list( REMOVE_ITEM ${__availableToolchainsVar} "${__toolchain}" )
+  endif()
+  unset( __gcc_toolchain )
+ endforeach()
+endmacro()
+
 # get all the details about NDK
 if( BUILD_WITH_ANDROID_NDK )
  file( GLOB ANDROID_SUPPORTED_NATIVE_API_LEVELS RELATIVE "${ANDROID_NDK}/platforms" "${ANDROID_NDK}/platforms/android-*" )
  string( REPLACE "android-" "" ANDROID_SUPPORTED_NATIVE_API_LEVELS "${ANDROID_SUPPORTED_NATIVE_API_LEVELS}" )
- file( GLOB __availableToolchains RELATIVE "${ANDROID_NDK}/toolchains" "${ANDROID_NDK}/toolchains/*" )
- __LIST_FILTER( __availableToolchains "^[.]" )
+ set( __availableToolchains "" )
  set( __availableToolchainMachines "" )
  set( __availableToolchainArchs "" )
  set( __availableToolchainCompilerVersions "" )
- foreach( __toolchain ${__availableToolchains} )
-  __DETECT_TOOLCHAIN_MACHINE_NAME( __machine "${ANDROID_NDK}/toolchains/${__toolchain}/prebuilt/${ANDROID_NDK_HOST_SYSTEM_NAME}" )
-  if( __machine )
-   string( REGEX MATCH "[0-9]+[.][0-9]+([.][0-9]+)?$" __version "${__toolchain}" )
-   string( REGEX MATCH "^[^-]+" __arch "${__toolchain}" )
-   list( APPEND __availableToolchainMachines "${__machine}" )
-   list( APPEND __availableToolchainArchs "${__arch}" )
-   list( APPEND __availableToolchainCompilerVersions "${__version}" )
-  else()
-   list( REMOVE_ITEM __availableToolchains "${__toolchain}" )
-  endif()
- endforeach()
+ if( ANDROID_TOOLCHAIN_NAME AND EXISTS "${ANDROID_NDK}/toolchains/${ANDROID_TOOLCHAIN_NAME}/" )
+  # do not go through all toolchains if we know the name
+  set( __availableToolchains "${ANDROID_TOOLCHAIN_NAME}" )
+  __GLOB_NDK_TOOLCHAINS( __availableToolchains )
+ endif()
  if( NOT __availableToolchains )
-  message( FATAL_ERROR "Could not any working toolchain in the NDK. Probably your Android NDK is broken." )
+  file( GLOB __availableToolchains RELATIVE "${ANDROID_NDK}/toolchains" "${ANDROID_NDK}/toolchains/*" )
+  if( __availableToolchains )
+   list(SORT __availableToolchains) # we need clang to go after gcc
+  endif()
+  __LIST_FILTER( __availableToolchains "^[.]" )
+  __LIST_FILTER( __availableToolchains "llvm" )
+  __GLOB_NDK_TOOLCHAINS( __availableToolchains )
+ endif()
+ if( NOT __availableToolchains )
+  message( FATAL_ERROR "Could not find any working toolchain in the NDK. Probably your Android NDK is broken." )
  endif()
 endif()
 
 # build list of available ABIs
+set( ANDROID_SUPPORTED_ABIS "" )
+set( __uniqToolchainArchNames ${__availableToolchainArchs} )
+list( REMOVE_DUPLICATES __uniqToolchainArchNames )
+list( SORT __uniqToolchainArchNames )
+foreach( __arch ${__uniqToolchainArchNames} )
+list( APPEND ANDROID_SUPPORTED_ABIS ${ANDROID_SUPPORTED_ABIS_${__arch}} )
+endforeach()
+unset( __uniqToolchainArchNames )
 if( NOT ANDROID_SUPPORTED_ABIS )
- set( ANDROID_SUPPORTED_ABIS "" )
- set( __uniqToolchainArchNames ${__availableToolchainArchs} )
- list( REMOVE_DUPLICATES __uniqToolchainArchNames )
- list( SORT __uniqToolchainArchNames )
- foreach( __arch ${__uniqToolchainArchNames} )
-  list( APPEND ANDROID_SUPPORTED_ABIS ${ANDROID_SUPPORTED_ABIS_${__arch}} )
- endforeach()
- unset( __uniqToolchainArchNames )
- if( NOT ANDROID_SUPPORTED_ABIS )
-  message( FATAL_ERROR "No one of known Android ABIs is supported by this cmake toolchain." )
- endif()
+message( FATAL_ERROR "No one of known Android ABIs is supported by this cmake toolchain." )
 endif()
 
 # choose target ABI
@@ -569,33 +636,34 @@ if( __androidAbiIdx EQUAL -1 )
 endif()
 unset( __androidAbiIdx )
 
-# remember target ABI
-set( ANDROID_ABI "${ANDROID_ABI}" CACHE STRING "The target ABI for Android. If arm, then armeabi-v7a is recommended for hardware floating point." FORCE )
-
 # set target ABI options
 if( ANDROID_ABI STREQUAL "x86" )
  set( X86 true )
  set( ANDROID_NDK_ABI_NAME "x86" )
  set( ANDROID_ARCH_NAME "x86" )
  set( ANDROID_ARCH_FULLNAME "x86" )
+ set( ANDROID_LLVM_TRIPLE "i686-none-linux-android" )
  set( CMAKE_SYSTEM_PROCESSOR "i686" )
 elseif( ANDROID_ABI STREQUAL "mips" )
  set( MIPS true )
  set( ANDROID_NDK_ABI_NAME "mips" )
  set( ANDROID_ARCH_NAME "mips" )
  set( ANDROID_ARCH_FULLNAME "mipsel" )
+ set( ANDROID_LLVM_TRIPLE "mipsel-none-linux-android" )
  set( CMAKE_SYSTEM_PROCESSOR "mips" )
 elseif( ANDROID_ABI STREQUAL "armeabi" )
  set( ARMEABI true )
  set( ANDROID_NDK_ABI_NAME "armeabi" )
  set( ANDROID_ARCH_NAME "arm" )
  set( ANDROID_ARCH_FULLNAME "arm" )
+ set( ANDROID_LLVM_TRIPLE "armv5te-none-linux-androideabi" )
  set( CMAKE_SYSTEM_PROCESSOR "armv5te" )
 elseif( ANDROID_ABI STREQUAL "armeabi-v6 with VFP" )
  set( ARMEABI_V6 true )
  set( ANDROID_NDK_ABI_NAME "armeabi" )
  set( ANDROID_ARCH_NAME "arm" )
  set( ANDROID_ARCH_FULLNAME "arm" )
+ set( ANDROID_LLVM_TRIPLE "armv5te-none-linux-androideabi" )
  set( CMAKE_SYSTEM_PROCESSOR "armv6" )
  # need always fallback to older platform
  set( ARMEABI true )
@@ -604,12 +672,14 @@ elseif( ANDROID_ABI STREQUAL "armeabi-v7a")
  set( ANDROID_NDK_ABI_NAME "armeabi-v7a" )
  set( ANDROID_ARCH_NAME "arm" )
  set( ANDROID_ARCH_FULLNAME "arm" )
+ set( ANDROID_LLVM_TRIPLE "armv7-none-linux-androideabi" )
  set( CMAKE_SYSTEM_PROCESSOR "armv7-a" )
 elseif( ANDROID_ABI STREQUAL "armeabi-v7a with VFPV3" )
  set( ARMEABI_V7A true )
  set( ANDROID_NDK_ABI_NAME "armeabi-v7a" )
  set( ANDROID_ARCH_NAME "arm" )
  set( ANDROID_ARCH_FULLNAME "arm" )
+ set( ANDROID_LLVM_TRIPLE "armv7-none-linux-androideabi" )
  set( CMAKE_SYSTEM_PROCESSOR "armv7-a" )
  set( VFPV3 true )
 elseif( ANDROID_ABI STREQUAL "armeabi-v7a with NEON" )
@@ -617,6 +687,7 @@ elseif( ANDROID_ABI STREQUAL "armeabi-v7a with NEON" )
  set( ANDROID_NDK_ABI_NAME "armeabi-v7a" )
  set( ANDROID_ARCH_NAME "arm" )
  set( ANDROID_ARCH_FULLNAME "arm" )
+ set( ANDROID_LLVM_TRIPLE "armv7-none-linux-androideabi" )
  set( CMAKE_SYSTEM_PROCESSOR "armv7-a" )
  set( VFPV3 true )
  set( NEON true )
@@ -630,12 +701,6 @@ if( CMAKE_BINARY_DIR AND EXISTS "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMa
  file( APPEND "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeSystem.cmake" "SET(CMAKE_SYSTEM_PROCESSOR \"${CMAKE_SYSTEM_PROCESSOR}\")\n" )
 endif()
 
-set( ANDROID_SUPPORTED_ABIS ${ANDROID_SUPPORTED_ABIS_${ANDROID_ARCH_FULLNAME}} CACHE INTERNAL "ANDROID_ABI can be changed only to one of these ABIs. Changing to any other ABI requires to reset cmake cache." FORCE )
-if( CMAKE_VERSION VERSION_GREATER "2.8" )
- list( SORT ANDROID_SUPPORTED_ABIS_${ANDROID_ARCH_FULLNAME} )
- set_property( CACHE ANDROID_ABI PROPERTY STRINGS ${ANDROID_SUPPORTED_ABIS_${ANDROID_ARCH_FULLNAME}} )
-endif()
-
 if( ANDROID_ARCH_NAME STREQUAL "arm" AND NOT ARMEABI_V6 )
  __INIT_VARIABLE( ANDROID_FORCE_ARM_BUILD OBSOLETE_FORCE_ARM VALUES OFF )
  set( ANDROID_FORCE_ARM_BUILD ${ANDROID_FORCE_ARM_BUILD} CACHE BOOL "Use 32-bit ARM instructions instead of Thumb-1" FORCE )
@@ -648,11 +713,15 @@ endif()
 if( ANDROID_TOOLCHAIN_NAME )
  list( FIND __availableToolchains "${ANDROID_TOOLCHAIN_NAME}" __toolchainIdx )
  if( __toolchainIdx EQUAL -1 )
-  message( FATAL_ERROR "Previously selected toolchain \"${ANDROID_TOOLCHAIN_NAME}\" is missing. You need to remove CMakeCache.txt and rerun cmake manually to change the toolchain" )
+  list( SORT __availableToolchains )
+  string( REPLACE ";" "\n  * " toolchains_list "${__availableToolchains}" )
+  set( toolchains_list "  * ${toolchains_list}")
+  message( FATAL_ERROR "Specified toolchain \"${ANDROID_TOOLCHAIN_NAME}\" is missing in your NDK or broken. Please verify that your NDK is working or select another compiler toolchain.
+To configure the toolchain set CMake variable ANDROID_TOOLCHAIN_NAME to one of the following values:\n${toolchains_list}\n" )
  endif()
  list( GET __availableToolchainArchs ${__toolchainIdx} __toolchainArch )
  if( NOT __toolchainArch STREQUAL ANDROID_ARCH_FULLNAME )
-  message( SEND_ERROR "Previously selected toolchain \"${ANDROID_TOOLCHAIN_NAME}\" is not able to compile binaries for the \"${ANDROID_ARCH_NAME}\" platform." )
+  message( SEND_ERROR "Selected toolchain \"${ANDROID_TOOLCHAIN_NAME}\" is not able to compile binaries for the \"${ANDROID_ARCH_NAME}\" platform." )
  endif()
 else()
  set( __toolchainIdx -1 )
@@ -681,8 +750,7 @@ endif()
 list( GET __availableToolchains ${__toolchainIdx} ANDROID_TOOLCHAIN_NAME )
 list( GET __availableToolchainMachines ${__toolchainIdx} ANDROID_TOOLCHAIN_MACHINE_NAME )
 list( GET __availableToolchainCompilerVersions ${__toolchainIdx} ANDROID_COMPILER_VERSION )
-set( ANDROID_TOOLCHAIN_NAME "${ANDROID_TOOLCHAIN_NAME}" CACHE INTERNAL "Name of toolchain used" FORCE )
-set( ANDROID_COMPILER_VERSION "${ANDROID_COMPILER_VERSION}" CACHE INTERNAL "compiler version from selected toolchain" FORCE )
+
 unset( __toolchainIdx )
 unset( __availableToolchains )
 unset( __availableToolchainMachines )
@@ -692,37 +760,35 @@ unset( __availableToolchainCompilerVersions )
 # choose native API level
 __INIT_VARIABLE( ANDROID_NATIVE_API_LEVEL ENV_ANDROID_NATIVE_API_LEVEL ANDROID_API_LEVEL ENV_ANDROID_API_LEVEL ANDROID_STANDALONE_TOOLCHAIN_API_LEVEL ANDROID_DEFAULT_NDK_API_LEVEL_${ANDROID_ARCH_NAME} ANDROID_DEFAULT_NDK_API_LEVEL )
 string( REGEX MATCH "[0-9]+" ANDROID_NATIVE_API_LEVEL "${ANDROID_NATIVE_API_LEVEL}" )
+# TODO: filter out unsupported levels
 # validate
 list( FIND ANDROID_SUPPORTED_NATIVE_API_LEVELS "${ANDROID_NATIVE_API_LEVEL}" __levelIdx )
 if( __levelIdx EQUAL -1 )
  message( SEND_ERROR "Specified Android native API level (${ANDROID_NATIVE_API_LEVEL}) is not supported by your NDK/toolchain." )
+else()
+ if( BUILD_WITH_ANDROID_NDK )
+  __DETECT_NATIVE_API_LEVEL( __realApiLevel "${ANDROID_NDK}/platforms/android-${ANDROID_NATIVE_API_LEVEL}/arch-${ANDROID_ARCH_NAME}/usr/include/android/api-level.h" )
+  if( NOT __realApiLevel EQUAL ANDROID_NATIVE_API_LEVEL )
+   message( SEND_ERROR "Specified Android API level (${ANDROID_NATIVE_API_LEVEL}) does not match to the level found (${__realApiLevel}). Probably your copy of NDK is broken." )
+  endif()
+  unset( __realApiLevel )
+ endif()
+ set( ANDROID_NATIVE_API_LEVEL "${ANDROID_NATIVE_API_LEVEL}" CACHE STRING "Android API level for native code" FORCE )
+ if( CMAKE_VERSION VERSION_GREATER "2.8" )
+  list( SORT ANDROID_SUPPORTED_NATIVE_API_LEVELS )
+  set_property( CACHE ANDROID_NATIVE_API_LEVEL PROPERTY STRINGS ${ANDROID_SUPPORTED_NATIVE_API_LEVELS} )
+ endif()
 endif()
 unset( __levelIdx )
-if( BUILD_WITH_ANDROID_NDK )
- __DETECT_NATIVE_API_LEVEL( __realApiLevel "${ANDROID_NDK}/platforms/android-${ANDROID_NATIVE_API_LEVEL}/arch-${ANDROID_ARCH_NAME}/usr/include/android/api-level.h" )
- if( NOT __realApiLevel EQUAL ANDROID_NATIVE_API_LEVEL )
-  message( SEND_ERROR "Specified Android API level (${ANDROID_NATIVE_API_LEVEL}) does not match to the level found (${__realApiLevel}). Probably your copy of NDK is broken." )
- endif()
- unset( __realApiLevel )
-endif()
-set( ANDROID_NATIVE_API_LEVEL "${ANDROID_NATIVE_API_LEVEL}" CACHE STRING "Android API level for native code" FORCE )
+
+
+# remember target ABI
+set( ANDROID_ABI "${ANDROID_ABI}" CACHE STRING "The target ABI for Android. If arm, then armeabi-v7a is recommended for hardware floating point." FORCE )
 if( CMAKE_VERSION VERSION_GREATER "2.8" )
- list( SORT ANDROID_SUPPORTED_NATIVE_API_LEVELS )
- set_property( CACHE ANDROID_NATIVE_API_LEVEL PROPERTY STRINGS ${ANDROID_SUPPORTED_NATIVE_API_LEVELS} )
+ list( SORT ANDROID_SUPPORTED_ABIS_${ANDROID_ARCH_FULLNAME} )
+ set_property( CACHE ANDROID_ABI PROPERTY STRINGS ${ANDROID_SUPPORTED_ABIS_${ANDROID_ARCH_FULLNAME}} )
 endif()
 
-# setup output directories
-set( LIBRARY_OUTPUT_PATH_ROOT ${CMAKE_SOURCE_DIR} CACHE PATH "root for library output, set this to change where android libs are installed to" )
-set( CMAKE_INSTALL_PREFIX "${ANDROID_TOOLCHAIN_ROOT}/user" CACHE STRING "path for installing" )
-
-if(NOT _CMAKE_IN_TRY_COMPILE)
- if( EXISTS "${CMAKE_SOURCE_DIR}/jni/CMakeLists.txt" )
-  set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin/${ANDROID_NDK_ABI_NAME}" CACHE PATH "Output directory for applications" )
- else()
-  set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin" CACHE PATH "Output directory for applications" )
- endif()
- set( LIBRARY_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/libs/${ANDROID_NDK_ABI_NAME}" CACHE PATH "path for android libs" )
-endif()
 
 # runtime choice (STL, rtti, exceptions)
 if( NOT ANDROID_STL )
@@ -800,83 +866,11 @@ See https://android.googlesource.com/platform/development.git f907f4f9d4e56ccc80
 " )
 endif()
 
-# setup paths and STL for NDK
-if( BUILD_WITH_ANDROID_NDK )
- set( ANDROID_TOOLCHAIN_ROOT "${ANDROID_NDK}/toolchains/${ANDROID_TOOLCHAIN_NAME}/prebuilt/${ANDROID_NDK_HOST_SYSTEM_NAME}" )
- set( ANDROID_SYSROOT "${ANDROID_NDK}/platforms/android-${ANDROID_NATIVE_API_LEVEL}/arch-${ANDROID_ARCH_NAME}" )
-
- if( ANDROID_STL STREQUAL "none" )
-  # do nothing
- elseif( ANDROID_STL STREQUAL "system" )
-  set( ANDROID_RTTI             OFF )
-  set( ANDROID_EXCEPTIONS       OFF )
-  set( ANDROID_STL_INCLUDE_DIRS "${ANDROID_NDK}/sources/cxx-stl/system/include" )
- elseif( ANDROID_STL STREQUAL "system_re" )
-  set( ANDROID_RTTI             ON )
-  set( ANDROID_EXCEPTIONS       ON )
-  set( ANDROID_STL_INCLUDE_DIRS "${ANDROID_NDK}/sources/cxx-stl/system/include" )
- elseif( ANDROID_STL MATCHES "gabi" )
-  if( ANDROID_NDK_RELEASE STRLESS "r7" )
-   message( FATAL_ERROR "gabi++ is not awailable in your NDK. You have to upgrade to NDK r7 or newer to use gabi++.")
-  endif()
-  set( ANDROID_RTTI             ON )
-  set( ANDROID_EXCEPTIONS       OFF )
-  set( ANDROID_STL_INCLUDE_DIRS "${ANDROID_NDK}/sources/cxx-stl/gabi++/include" )
-  set( __libstl                 "${ANDROID_NDK}/sources/cxx-stl/gabi++/libs/${ANDROID_NDK_ABI_NAME}/libgabi++_static.a" )
- elseif( ANDROID_STL MATCHES "stlport" )
-  set( ANDROID_EXCEPTIONS       OFF )
-  if( ANDROID_NDK_RELEASE STRLESS "r7" )
-   set( ANDROID_RTTI            OFF )
-  else()
-   set( ANDROID_RTTI            ON )
-  endif()
-  set( ANDROID_STL_INCLUDE_DIRS "${ANDROID_NDK}/sources/cxx-stl/stlport/stlport" )
-  set( __libstl                 "${ANDROID_NDK}/sources/cxx-stl/stlport/libs/${ANDROID_NDK_ABI_NAME}/libstlport_static.a" )
- elseif( ANDROID_STL MATCHES "gnustl" )
-  set( ANDROID_EXCEPTIONS       ON )
-  set( ANDROID_RTTI             ON )
-  if( EXISTS "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/${ANDROID_COMPILER_VERSION}" )
-   set( __libstl                "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/${ANDROID_COMPILER_VERSION}" )
-  else()
-   set( __libstl                "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++" )
-  endif()
-  set( ANDROID_STL_INCLUDE_DIRS "${__libstl}/include" "${__libstl}/libs/${ANDROID_NDK_ABI_NAME}/include" )
-  if( EXISTS "${__libstl}/libs/${ANDROID_NDK_ABI_NAME}/libgnustl_static.a" )
-   set( __libstl                "${__libstl}/libs/${ANDROID_NDK_ABI_NAME}/libgnustl_static.a" )
-  else()
-   set( __libstl                "${__libstl}/libs/${ANDROID_NDK_ABI_NAME}/libstdc++.a" )
-  endif()
- else()
-  message( FATAL_ERROR "Unknown runtime: ${ANDROID_STL}" )
- endif()
- # find libsupc++.a - rtti & exceptions
- if( ANDROID_STL STREQUAL "system_re" OR ANDROID_STL MATCHES "gnustl" )
-  if( ANDROID_NDK_RELEASE STRGREATER "r8" ) # r8b
-   set( __libsupcxx "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/${ANDROID_COMPILER_VERSION}/libs/${ANDROID_NDK_ABI_NAME}/libsupc++.a" )
-  elseif( NOT ANDROID_NDK_RELEASE STRLESS "r7" AND ANDROID_NDK_RELEASE STRLESS "r8b")
-   set( __libsupcxx "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/libs/${ANDROID_NDK_ABI_NAME}/libsupc++.a" )
-  else( ANDROID_NDK_RELEASE STRLESS "r7" )
-   if( ARMEABI_V7A )
-    if( ANDROID_FORCE_ARM_BUILD )
-     set( __libsupcxx "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/libsupc++.a" )
-    else()
-     set( __libsupcxx "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/thumb/libsupc++.a" )
-    endif()
-   elseif( ARMEABI AND NOT ANDROID_FORCE_ARM_BUILD )
-    set( __libsupcxx "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb/libsupc++.a" )
-   else()
-    set( __libsupcxx "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/libsupc++.a" )
-   endif()
-  endif()
-  if( NOT EXISTS "${__libsupcxx}")
-   message( ERROR "Could not find libsupc++.a for a chosen platform. Either your NDK is not supported or is broken.")
-  endif()
- endif()
-endif()
 
 # setup paths and STL for standalone toolchain
 if( BUILD_WITH_STANDALONE_TOOLCHAIN )
  set( ANDROID_TOOLCHAIN_ROOT "${ANDROID_STANDALONE_TOOLCHAIN}" )
+ set( ANDROID_CLANG_TOOLCHAIN_ROOT "${ANDROID_STANDALONE_TOOLCHAIN}" )
  set( ANDROID_SYSROOT "${ANDROID_STANDALONE_TOOLCHAIN}/sysroot" )
 
  if( NOT ANDROID_STL STREQUAL "none" )
@@ -923,6 +917,115 @@ if( BUILD_WITH_STANDALONE_TOOLCHAIN )
  endif()
 endif()
 
+# clang
+if( "${ANDROID_TOOLCHAIN_NAME}" STREQUAL "standalone-clang" )
+ set( ANDROID_COMPILER_IS_CLANG 1 )
+ execute_process( COMMAND "${ANDROID_CLANG_TOOLCHAIN_ROOT}/bin/clang${TOOL_OS_SUFFIX}" --version OUTPUT_VARIABLE ANDROID_CLANG_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE )
+ string( REGEX MATCH "[0-9]+[.][0-9]+" ANDROID_CLANG_VERSION "${ANDROID_CLANG_VERSION}")
+elseif( "${ANDROID_TOOLCHAIN_NAME}" MATCHES "-clang3[.][0-9]?$" )
+ string( REGEX MATCH "3[.][0-9]$" ANDROID_CLANG_VERSION "${ANDROID_TOOLCHAIN_NAME}")
+ string( REGEX REPLACE "-clang${ANDROID_CLANG_VERSION}$" "-4.6" ANDROID_GCC_TOOLCHAIN_NAME "${ANDROID_TOOLCHAIN_NAME}" )
+ if( NOT EXISTS "${ANDROID_NDK}/toolchains/llvm-${ANDROID_CLANG_VERSION}/prebuilt/${ANDROID_NDK_HOST_SYSTEM_NAME}/bin/clang${TOOL_OS_SUFFIX}" )
+  message( FATAL_ERROR "Could not find the " )
+ endif()
+ set( ANDROID_COMPILER_IS_CLANG 1 )
+ set( ANDROID_CLANG_TOOLCHAIN_ROOT "${ANDROID_NDK}/toolchains/llvm-${ANDROID_CLANG_VERSION}/prebuilt/${ANDROID_NDK_HOST_SYSTEM_NAME}" )
+else()
+ set( ANDROID_GCC_TOOLCHAIN_NAME "${ANDROID_TOOLCHAIN_NAME}" )
+ unset( ANDROID_COMPILER_IS_CLANG CACHE )
+endif()
+
+string( REPLACE "." "" _clang_name "clang${ANDROID_CLANG_VERSION}" )
+if( NOT EXISTS "${ANDROID_CLANG_TOOLCHAIN_ROOT}/bin/${_clang_name}${TOOL_OS_SUFFIX}" )
+ set( _clang_name "clang" )
+endif()
+
+
+# setup paths and STL for NDK
+if( BUILD_WITH_ANDROID_NDK )
+ set( ANDROID_TOOLCHAIN_ROOT "${ANDROID_NDK}/toolchains/${ANDROID_GCC_TOOLCHAIN_NAME}/prebuilt/${ANDROID_NDK_HOST_SYSTEM_NAME}" )
+ set( ANDROID_SYSROOT "${ANDROID_NDK}/platforms/android-${ANDROID_NATIVE_API_LEVEL}/arch-${ANDROID_ARCH_NAME}" )
+
+ if( ANDROID_STL STREQUAL "none" )
+  # do nothing
+ elseif( ANDROID_STL STREQUAL "system" )
+  set( ANDROID_RTTI             OFF )
+  set( ANDROID_EXCEPTIONS       OFF )
+  set( ANDROID_STL_INCLUDE_DIRS "${ANDROID_NDK}/sources/cxx-stl/system/include" )
+ elseif( ANDROID_STL STREQUAL "system_re" )
+  set( ANDROID_RTTI             ON )
+  set( ANDROID_EXCEPTIONS       ON )
+  set( ANDROID_STL_INCLUDE_DIRS "${ANDROID_NDK}/sources/cxx-stl/system/include" )
+ elseif( ANDROID_STL MATCHES "gabi" )
+  if( ANDROID_NDK_RELEASE STRLESS "r7" )
+   message( FATAL_ERROR "gabi++ is not awailable in your NDK. You have to upgrade to NDK r7 or newer to use gabi++.")
+  endif()
+  set( ANDROID_RTTI             ON )
+  set( ANDROID_EXCEPTIONS       OFF )
+  set( ANDROID_STL_INCLUDE_DIRS "${ANDROID_NDK}/sources/cxx-stl/gabi++/include" )
+  set( __libstl                 "${ANDROID_NDK}/sources/cxx-stl/gabi++/libs/${ANDROID_NDK_ABI_NAME}/libgabi++_static.a" )
+ elseif( ANDROID_STL MATCHES "stlport" )
+  if( NOT ANDROID_NDK_RELEASE STRLESS "r8d" )
+   set( ANDROID_EXCEPTIONS       ON )
+  else()
+   set( ANDROID_EXCEPTIONS       OFF )
+  endif()
+  if( ANDROID_NDK_RELEASE STRLESS "r7" )
+   set( ANDROID_RTTI            OFF )
+  else()
+   set( ANDROID_RTTI            ON )
+  endif()
+  set( ANDROID_STL_INCLUDE_DIRS "${ANDROID_NDK}/sources/cxx-stl/stlport/stlport" )
+  set( __libstl                 "${ANDROID_NDK}/sources/cxx-stl/stlport/libs/${ANDROID_NDK_ABI_NAME}/libstlport_static.a" )
+ elseif( ANDROID_STL MATCHES "gnustl" )
+  set( ANDROID_EXCEPTIONS       ON )
+  set( ANDROID_RTTI             ON )
+  if( EXISTS "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/${ANDROID_COMPILER_VERSION}" )
+   if( ARMEABI_V7A AND ANDROID_COMPILER_VERSION VERSION_EQUAL "4.7" AND ANDROID_NDK_RELEASE STREQUAL "r8d" )
+    # gnustl binary for 4.7 compiler is buggy :(
+    # TODO: look for right fix
+    set( __libstl                "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/4.6" )
+   else()
+    set( __libstl                "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/${ANDROID_COMPILER_VERSION}" )
+   endif()
+  else()
+   set( __libstl                "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++" )
+  endif()
+  set( ANDROID_STL_INCLUDE_DIRS "${__libstl}/include" "${__libstl}/libs/${ANDROID_NDK_ABI_NAME}/include" )
+  if( EXISTS "${__libstl}/libs/${ANDROID_NDK_ABI_NAME}/libgnustl_static.a" )
+   set( __libstl                "${__libstl}/libs/${ANDROID_NDK_ABI_NAME}/libgnustl_static.a" )
+  else()
+   set( __libstl                "${__libstl}/libs/${ANDROID_NDK_ABI_NAME}/libstdc++.a" )
+  endif()
+ else()
+  message( FATAL_ERROR "Unknown runtime: ${ANDROID_STL}" )
+ endif()
+ # find libsupc++.a - rtti & exceptions
+ if( ANDROID_STL STREQUAL "system_re" OR ANDROID_STL MATCHES "gnustl" )
+  if( ANDROID_NDK_RELEASE STRGREATER "r8" ) # r8b
+   set( __libsupcxx "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/${ANDROID_COMPILER_VERSION}/libs/${ANDROID_NDK_ABI_NAME}/libsupc++.a" )
+  elseif( NOT ANDROID_NDK_RELEASE STRLESS "r7" AND ANDROID_NDK_RELEASE STRLESS "r8b")
+   set( __libsupcxx "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/libs/${ANDROID_NDK_ABI_NAME}/libsupc++.a" )
+  else( ANDROID_NDK_RELEASE STRLESS "r7" )
+   if( ARMEABI_V7A )
+    if( ANDROID_FORCE_ARM_BUILD )
+     set( __libsupcxx "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/libsupc++.a" )
+    else()
+     set( __libsupcxx "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/thumb/libsupc++.a" )
+    endif()
+   elseif( ARMEABI AND NOT ANDROID_FORCE_ARM_BUILD )
+    set( __libsupcxx "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb/libsupc++.a" )
+   else()
+    set( __libsupcxx "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/libsupc++.a" )
+   endif()
+  endif()
+  if( NOT EXISTS "${__libsupcxx}")
+   message( ERROR "Could not find libsupc++.a for a chosen platform. Either your NDK is not supported or is broken.")
+  endif()
+ endif()
+endif()
+
+
 # case of shared STL linkage
 if( ANDROID_STL MATCHES "shared" AND DEFINED __libstl )
  string( REPLACE "_static.a" "_shared.so" __libstl "${__libstl}" )
@@ -937,25 +1040,40 @@ if( ANDROID_STL MATCHES "shared" AND DEFINED __libstl )
  endif()
 endif()
 
+
 # ccache support
 __INIT_VARIABLE( _ndk_ccache NDK_CCACHE ENV_NDK_CCACHE )
 if( _ndk_ccache )
+ if( DEFINED NDK_CCACHE AND NOT EXISTS NDK_CCACHE )
+  unset( NDK_CCACHE CACHE )
+ endif()
  find_program( NDK_CCACHE "${_ndk_ccache}" DOC "The path to ccache binary")
 else()
  unset( NDK_CCACHE CACHE )
 endif()
 unset( _ndk_ccache )
 
+
 # setup the cross-compiler
 if( NOT CMAKE_C_COMPILER )
  if( NDK_CCACHE )
   set( CMAKE_C_COMPILER   "${NDK_CCACHE}" CACHE PATH "ccache as C compiler" )
   set( CMAKE_CXX_COMPILER "${NDK_CCACHE}" CACHE PATH "ccache as C++ compiler" )
-  set( CMAKE_C_COMPILER_ARG1 "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-gcc${TOOL_OS_SUFFIX}"   CACHE PATH "gcc")
-  set( CMAKE_CXX_COMPILER_ARG1 "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-g++${TOOL_OS_SUFFIX}" CACHE PATH "g++")
+  if( ANDROID_COMPILER_IS_CLANG )
+   set( CMAKE_C_COMPILER_ARG1   "${ANDROID_CLANG_TOOLCHAIN_ROOT}/bin/${_clang_name}${TOOL_OS_SUFFIX}"   CACHE PATH "C compiler")
+   set( CMAKE_CXX_COMPILER_ARG1 "${ANDROID_CLANG_TOOLCHAIN_ROOT}/bin/${_clang_name}++${TOOL_OS_SUFFIX}" CACHE PATH "C++ compiler")
+  else()
+   set( CMAKE_C_COMPILER_ARG1   "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-gcc${TOOL_OS_SUFFIX}" CACHE PATH "C compiler")
+   set( CMAKE_CXX_COMPILER_ARG1 "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-g++${TOOL_OS_SUFFIX}" CACHE PATH "C++ compiler")
+  endif()
  else()
-  set( CMAKE_C_COMPILER   "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-gcc${TOOL_OS_SUFFIX}"    CACHE PATH "gcc" )
-  set( CMAKE_CXX_COMPILER "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-g++${TOOL_OS_SUFFIX}"    CACHE PATH "g++" )
+  if( ANDROID_COMPILER_IS_CLANG )
+   set( CMAKE_C_COMPILER   "${ANDROID_CLANG_TOOLCHAIN_ROOT}/bin/${_clang_name}${TOOL_OS_SUFFIX}"   CACHE PATH "C compiler")
+   set( CMAKE_CXX_COMPILER "${ANDROID_CLANG_TOOLCHAIN_ROOT}/bin/${_clang_name}++${TOOL_OS_SUFFIX}" CACHE PATH "C++ compiler")
+  else()
+   set( CMAKE_C_COMPILER   "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-gcc${TOOL_OS_SUFFIX}"    CACHE PATH "C compiler" )
+   set( CMAKE_CXX_COMPILER "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-g++${TOOL_OS_SUFFIX}"    CACHE PATH "C++ compiler" )
+  endif()
  endif()
  set( CMAKE_ASM_COMPILER "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-gcc${TOOL_OS_SUFFIX}"     CACHE PATH "assembler" )
  set( CMAKE_STRIP        "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-strip${TOOL_OS_SUFFIX}"   CACHE PATH "strip" )
@@ -982,15 +1100,22 @@ endif()
 # Force set compilers because standard identification works badly for us
 include( CMakeForceCompiler )
 CMAKE_FORCE_C_COMPILER( "${CMAKE_C_COMPILER}" GNU )
+if( ANDROID_COMPILER_IS_CLANG )
+ set( CMAKE_C_COMPILER_ID Clang)
+endif()
 set( CMAKE_C_PLATFORM_ID Linux )
 set( CMAKE_C_SIZEOF_DATA_PTR 4 )
 set( CMAKE_C_HAS_ISYSROOT 1 )
 set( CMAKE_C_COMPILER_ABI ELF )
 CMAKE_FORCE_CXX_COMPILER( "${CMAKE_CXX_COMPILER}" GNU )
+if( ANDROID_COMPILER_IS_CLANG )
+ set( CMAKE_CXX_COMPILER_ID Clang)
+endif()
 set( CMAKE_CXX_PLATFORM_ID Linux )
 set( CMAKE_CXX_SIZEOF_DATA_PTR 4 )
 set( CMAKE_CXX_HAS_ISYSROOT 1 )
 set( CMAKE_CXX_COMPILER_ABI ELF )
+set( CMAKE_CXX_SOURCE_FILE_EXTENSIONS cc cp cxx cpp CPP c++ C )
 # force ASM compiler (required for CMake < 2.8.5)
 set( CMAKE_ASM_COMPILER_ID_RUN TRUE )
 set( CMAKE_ASM_COMPILER_ID GNU )
@@ -1056,10 +1181,10 @@ if( ARMEABI_V7A )
  elseif( VFPV3 )
   set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -mfpu=vfpv3" )
  else()
-  set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -mfpu=vfp" )
+  set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -mfpu=vfpv3-d16" )
  endif()
 elseif( ARMEABI_V6 )
- set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -march=armv6 -mfloat-abi=softfp -mfpu=vfp" )
+ set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -march=armv6 -mfloat-abi=softfp -mfpu=vfp" ) # vfp == vfpv2
 elseif( ARMEABI )
  set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -march=armv5te -mtune=xscale -msoft-float" )
 endif()
@@ -1148,17 +1273,25 @@ if( ANDROID_FUNCTION_LEVEL_LINKING )
  set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -Wl,--gc-sections" )
 endif()
 
-if( ANDROID_GOLD_LINKER AND CMAKE_HOST_UNIX AND (ARMEABI OR ARMEABI_V7A OR X86) AND ANDROID_COMPILER_VERSION VERSION_EQUAL "4.6" )
- set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -fuse-ld=gold" )
-elseif( ANDROID_NDK_RELEASE STREQUAL "r8b" AND ARMEABI AND ANDROID_COMPILER_VERSION VERSION_EQUAL "4.6" AND NOT _CMAKE_IN_TRY_COMPILE )
- message( WARNING "The default bfd linker from arm GCC 4.6 toolchain can fail with 'unresolvable R_ARM_THM_CALL relocation' error message. See https://code.google.com/p/android/issues/detail?id=35342
+if( ANDROID_COMPILER_VERSION VERSION_EQUAL "4.6" )
+ if( ANDROID_GOLD_LINKER AND (CMAKE_HOST_UNIX OR ANDROID_NDK_RELEASE STRGREATER "r8b") AND (ARMEABI OR ARMEABI_V7A OR X86) )
+  set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -fuse-ld=gold" )
+ elseif( ANDROID_NDK_RELEASE STRGREATER "r8b")
+  set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -fuse-ld=bfd" )
+ elseif( ANDROID_NDK_RELEASE STREQUAL "r8b" AND ARMEABI AND NOT _CMAKE_IN_TRY_COMPILE )
+  message( WARNING "The default bfd linker from arm GCC 4.6 toolchain can fail with 'unresolvable R_ARM_THM_CALL relocation' error message. See https://code.google.com/p/android/issues/detail?id=35342
   On Linux and OS X host platform you can workaround this problem using gold linker (default).
-  Rerun cmake with -DANDROID_GOLD_LINKER=ON option.
+  Rerun cmake with -DANDROID_GOLD_LINKER=ON option in case of problems.
 " )
-endif()
+ endif()
+endif() # version 4.6
 
 if( ANDROID_NOEXECSTACK )
- set( ANDROID_CXX_FLAGS    "${ANDROID_CXX_FLAGS} -Wa,--noexecstack" )
+ if( ANDROID_COMPILER_IS_CLANG )
+  set( ANDROID_CXX_FLAGS    "${ANDROID_CXX_FLAGS} -Xclang -mnoexecstack" )
+ else()
+  set( ANDROID_CXX_FLAGS    "${ANDROID_CXX_FLAGS} -Wa,--noexecstack" )
+ endif()
  set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -Wl,-z,noexecstack" )
 endif()
 
@@ -1166,6 +1299,22 @@ if( ANDROID_RELRO )
  set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -Wl,-z,relro -Wl,-z,now" )
 endif()
 
+if( ANDROID_COMPILER_IS_CLANG )
+ set( ANDROID_CXX_FLAGS "-Qunused-arguments ${ANDROID_CXX_FLAGS}" )
+ if( ARMEABI_V7A AND NOT ANDROID_FORCE_ARM_BUILD )
+  set( ANDROID_CXX_FLAGS_RELEASE "-target thumbv7-none-linux-androideabi ${ANDROID_CXX_FLAGS_RELEASE}" )
+  set( ANDROID_CXX_FLAGS_DEBUG   "-target ${ANDROID_LLVM_TRIPLE} ${ANDROID_CXX_FLAGS_DEBUG}" )
+ else()
+  set( ANDROID_CXX_FLAGS "-target ${ANDROID_LLVM_TRIPLE} ${ANDROID_CXX_FLAGS}" )
+ endif()
+ if( BUILD_WITH_ANDROID_NDK )
+  if(ANDROID_ARCH_NAME STREQUAL "arm" )
+   set( ANDROID_CXX_FLAGS "-isystem ${ANDROID_CLANG_TOOLCHAIN_ROOT}/lib/clang/${ANDROID_CLANG_VERSION}/include ${ANDROID_CXX_FLAGS}" )
+  endif()
+  set( ANDROID_CXX_FLAGS "-gcc-toolchain ${ANDROID_TOOLCHAIN_ROOT} ${ANDROID_CXX_FLAGS}" )
+ endif()
+endif()
+
 # cache flags
 set( CMAKE_CXX_FLAGS           ""                        CACHE STRING "c++ flags" )
 set( CMAKE_C_FLAGS             ""                        CACHE STRING "c flags" )
@@ -1189,9 +1338,9 @@ set( CMAKE_MODULE_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} ${CMAKE_MODULE_LINKER_FL
 set( CMAKE_EXE_LINKER_FLAGS    "${ANDROID_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS}" )
 
 if( MIPS AND BUILD_WITH_ANDROID_NDK AND ANDROID_NDK_RELEASE STREQUAL "r8" )
- set( CMAKE_SHARED_LINKER_FLAGS "-Wl,-T,${ANDROID_NDK}/toolchains/${ANDROID_TOOLCHAIN_NAME}/mipself.xsc ${CMAKE_SHARED_LINKER_FLAGS}" )
- set( CMAKE_MODULE_LINKER_FLAGS "-Wl,-T,${ANDROID_NDK}/toolchains/${ANDROID_TOOLCHAIN_NAME}/mipself.xsc ${CMAKE_MODULE_LINKER_FLAGS}" )
- set( CMAKE_EXE_LINKER_FLAGS    "-Wl,-T,${ANDROID_NDK}/toolchains/${ANDROID_TOOLCHAIN_NAME}/mipself.x ${CMAKE_EXE_LINKER_FLAGS}" )
+ set( CMAKE_SHARED_LINKER_FLAGS "-Wl,-T,${ANDROID_NDK}/toolchains/${ANDROID_GCC_TOOLCHAIN_NAME}/mipself.xsc ${CMAKE_SHARED_LINKER_FLAGS}" )
+ set( CMAKE_MODULE_LINKER_FLAGS "-Wl,-T,${ANDROID_NDK}/toolchains/${ANDROID_GCC_TOOLCHAIN_NAME}/mipself.xsc ${CMAKE_MODULE_LINKER_FLAGS}" )
+ set( CMAKE_EXE_LINKER_FLAGS    "-Wl,-T,${ANDROID_NDK}/toolchains/${ANDROID_GCC_TOOLCHAIN_NAME}/mipself.x ${CMAKE_EXE_LINKER_FLAGS}" )
 endif()
 
 # configure rtti
@@ -1218,6 +1367,19 @@ endif()
 include_directories( SYSTEM "${ANDROID_SYSROOT}/usr/include" ${ANDROID_STL_INCLUDE_DIRS} )
 link_directories( "${CMAKE_INSTALL_PREFIX}/libs/${ANDROID_NDK_ABI_NAME}" )
 
+# setup output directories
+set( LIBRARY_OUTPUT_PATH_ROOT ${CMAKE_SOURCE_DIR} CACHE PATH "root for library output, set this to change where android libs are installed to" )
+set( CMAKE_INSTALL_PREFIX "${ANDROID_TOOLCHAIN_ROOT}/user" CACHE STRING "path for installing" )
+
+if(NOT _CMAKE_IN_TRY_COMPILE)
+ if( EXISTS "${CMAKE_SOURCE_DIR}/jni/CMakeLists.txt" )
+  set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin/${ANDROID_NDK_ABI_NAME}" CACHE PATH "Output directory for applications" )
+ else()
+  set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin" CACHE PATH "Output directory for applications" )
+ endif()
+ set( LIBRARY_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/libs/${ANDROID_NDK_ABI_NAME}" CACHE PATH "path for android libs" )
+endif()
+
 # set these global flags for cmake client scripts to change behavior
 set( ANDROID True )
 set( BUILD_ANDROID True )
@@ -1335,7 +1497,7 @@ endif()
 # Variables controlling behavior or set by cmake toolchain:
 #   ANDROID_ABI : "armeabi-v7a" (default), "armeabi", "armeabi-v7a with NEON", "armeabi-v7a with VFPV3", "armeabi-v6 with VFP", "x86", "mips"
 #   ANDROID_NATIVE_API_LEVEL : 3,4,5,8,9,14 (depends on NDK version)
-#   ANDROID_SET_OBSOLETE_VARIABLES : ON/OFF
+#   ANDROID_STL : gnustl_static/gnustl_shared/stlport_static/stlport_shared/gabi++_static/gabi++_shared/system_re/system/none
 #   ANDROID_FORBID_SYGWIN : ON/OFF
 #   ANDROID_NO_UNDEFINED : ON/OFF
 #   ANDROID_SO_UNDEFINED : OFF/ON  (default depends on NDK version)
@@ -1343,16 +1505,15 @@ endif()
 #   ANDROID_GOLD_LINKER : ON/OFF
 #   ANDROID_NOEXECSTACK : ON/OFF
 #   ANDROID_RELRO : ON/OFF
-# Variables that takes effect only at first run:
 #   ANDROID_FORCE_ARM_BUILD : ON/OFF
-#   ANDROID_STL : gnustl_static/gnustl_shared/stlport_static/stlport_shared/gabi++_static/gabi++_shared/system_re/system/none
 #   ANDROID_STL_FORCE_FEATURES : ON/OFF
-#   LIBRARY_OUTPUT_PATH_ROOT : <any valid path>
-#   NDK_CCACHE : <path to your ccache executable>
+#   ANDROID_SET_OBSOLETE_VARIABLES : ON/OFF
 # Can be set only at the first run:
 #   ANDROID_NDK
 #   ANDROID_STANDALONE_TOOLCHAIN
-#   ANDROID_TOOLCHAIN_NAME : "arm-linux-androideabi-4.4.3" or "arm-linux-androideabi-4.6" or "mipsel-linux-android-4.4.3" or "mipsel-linux-android-4.6" or "x86-4.4.3" or "x86-4.6"
+#   ANDROID_TOOLCHAIN_NAME : the NDK name of compiler toolchain
+#   LIBRARY_OUTPUT_PATH_ROOT : <any valid path>
+#   NDK_CCACHE : <path to your ccache executable>
 # Obsolete:
 #   ANDROID_API_LEVEL : superseded by ANDROID_NATIVE_API_LEVEL
 #   ARM_TARGET : superseded by ANDROID_ABI
@@ -1375,10 +1536,11 @@ endif()
 #   BUILD_WITH_STANDALONE_TOOLCHAIN : TRUE if standalone toolchain is used
 #   ANDROID_NDK_HOST_SYSTEM_NAME : "windows", "linux-x86" or "darwin-x86" depending on host platform
 #   ANDROID_NDK_ABI_NAME : "armeabi", "armeabi-v7a", "x86" or "mips" depending on ANDROID_ABI
-#   ANDROID_NDK_RELEASE : one of r5, r5b, r5c, r6, r6b, r7, r7b, r7c, r8, r8b; set only for NDK
+#   ANDROID_NDK_RELEASE : one of r5, r5b, r5c, r6, r6b, r7, r7b, r7c, r8, r8b, r8c, r8d; set only for NDK
 #   ANDROID_ARCH_NAME : "arm" or "x86" or "mips" depending on ANDROID_ABI
 #   ANDROID_SYSROOT : path to the compiler sysroot
 #   TOOL_OS_SUFFIX : "" or ".exe" depending on host platform
+#   ANDROID_COMPILER_IS_CLANG : TRUE if clang compiler is used
 # Obsolete:
 #   ARMEABI_NDK_NAME : superseded by ANDROID_NDK_ABI_NAME
 #
@@ -1388,10 +1550,13 @@ endif()
 #   ANDROID_SUPPORTED_ABIS : list of currently allowed values for ANDROID_ABI
 #   ANDROID_TOOLCHAIN_MACHINE_NAME : "arm-linux-androideabi", "arm-eabi" or "i686-android-linux"
 #   ANDROID_TOOLCHAIN_ROOT : path to the top level of toolchain (standalone or placed inside NDK)
+#   ANDROID_CLANG_TOOLCHAIN_ROOT : path to clang tools
 #   ANDROID_SUPPORTED_NATIVE_API_LEVELS : list of native API levels found inside NDK
 #   ANDROID_STL_INCLUDE_DIRS : stl include paths
 #   ANDROID_RTTI : if rtti is enabled by the runtime
 #   ANDROID_EXCEPTIONS : if exceptions are enabled by the runtime
+#   ANDROID_GCC_TOOLCHAIN_NAME : read-only, differs from ANDROID_TOOLCHAIN_NAME only if clang is used
+#   ANDROID_CLANG_VERSION : version of clang compiler if clang is used
 #
 # Defaults:
 #   ANDROID_DEFAULT_NDK_API_LEVEL

android/java.rst

@@ -3,4 +3,4 @@ Java API
 ********
 
 
-`Java API reference external link (JavaDoc) <http://docs.opencv.org/java/>`_ 
+Java API reference (JavaDoc): external `link <http://docs.opencv.org/java/>`_.

android/libinfo/CMakeLists.txt

@@ -0,0 +1,39 @@
+project(libopencv_info)
+if(NOT ANDROID_PACKAGE_RELEASE)
+  set(ANDROID_PACKAGE_RELEASE 1)
+endif()
+
+if(NOT ANDROID_PACKAGE_PLATFORM)
+  if(ARMEABI_V7A)
+    if(NEON)
+      set(ANDROID_PACKAGE_PLATFORM armv7a_neon)
+    else()
+      set(ANDROID_PACKAGE_PLATFORM armv7a)
+    endif()
+  elseif(ARMEABI_V6)
+    set(ANDROID_PACKAGE_PLATFORM armv6)
+  elseif(ARMEABI)
+    set(ANDROID_PACKAGE_PLATFORM armv5)
+  elseif(X86)
+    set(ANDROID_PACKAGE_PLATFORM x86)
+  elseif(MIPS)
+    set(ANDROID_PACKAGE_PLATFORM mips)
+  else()
+    message(ERROR "Can not automatically determine the value for ANDROID_PACKAGE_PLATFORM")
+  endif()
+endif()
+
+add_definitions(-DANDROID_PACKAGE_RELEASE=${ANDROID_PACKAGE_RELEASE} -DANDROID_PACKAGE_PLATFORM="${ANDROID_PACKAGE_PLATFORM}")
+
+include_directories(jni/BinderComponent jni/include "${OpenCV_SOURCE_DIR}/modules/core/include")
+
+add_library(opencv_info SHARED info.c)
+
+set_target_properties(${the_module} PROPERTIES
+    ARCHIVE_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
+    RUNTIME_OUTPUT_DIRECTORY ${EXECUTABLE_OUTPUT_PATH}
+    INSTALL_NAME_DIR lib
+  )
+
+get_filename_component(lib_name "libopencv_info.so" NAME)
+install(FILES "${LIBRARY_OUTPUT_PATH}/${lib_name}" DESTINATION ${OPENCV_LIB_INSTALL_PATH} COMPONENT main)

android/libinfo/info.c

@@ -0,0 +1,31 @@
+#include "opencv2/core/version.hpp"
+#include <jni.h>
+
+const char* GetPackageName(void);
+const char* GetRevision(void);
+const char* GetLibraryList(void);
+JNIEXPORT jstring JNICALL Java_org_opencv_android_StaticHelper_getLibraryList(JNIEnv *, jclass);
+
+#define PACKAGE_NAME "org.opencv.lib_v" CVAUX_STR(CV_VERSION_EPOCH) CVAUX_STR(CV_VERSION_MAJOR) "_" ANDROID_PACKAGE_PLATFORM
+#define PACKAGE_REVISION CVAUX_STR(CV_VERSION_MINOR) "." CVAUX_STR(ANDROID_PACKAGE_RELEASE)
+
+const char* GetPackageName(void)
+{
+    return PACKAGE_NAME;
+}
+
+const char* GetRevision(void)
+{
+    return PACKAGE_REVISION;
+}
+
+const char* GetLibraryList(void)
+{
+    return "";
+}
+
+JNIEXPORT jstring JNICALL Java_org_opencv_android_StaticHelper_getLibraryList(JNIEnv * env, jclass clazz)
+{
+    (void)clazz;
+    return (*env)->NewStringUTF(env, GetLibraryList());
+}

android/package/CMakeLists.txt

@@ -56,7 +56,7 @@ configure_file("${CMAKE_CURRENT_SOURCE_DIR}/${ANDROID_MANIFEST_FILE}" "${PACKAGE
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/res/values/strings.xml"   "${PACKAGE_DIR}/res/values/strings.xml"    @ONLY)
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/res/drawable/icon.png"   "${PACKAGE_DIR}/res/drawable/icon.png"   COPYONLY)
 
-set(target_name "OpenCV_${OPENCV_VERSION_MAJOR}.${OPENCV_VERSION_MINOR}.${OPENCV_VERSION_PATCH}_binary_pack_${ANDROID_PACKAGE_PLATFORM}")
+set(target_name "OpenCV_${OPENCV_VERSION}_binary_pack_${ANDROID_PACKAGE_PLATFORM}")
 get_target_property(opencv_java_location opencv_java LOCATION)
 
 set(android_proj_target_files ${ANDROID_PROJECT_FILES})
@@ -86,7 +86,7 @@ add_custom_command(
          COMMAND ${CMAKE_COMMAND} -E touch "${APK_NAME}"
          WORKING_DIRECTORY "${PACKAGE_DIR}"
          MAIN_DEPENDENCY "${PACKAGE_DIR}/${ANDROID_MANIFEST_FILE}"
-         DEPENDS "${OpenCV_BINARY_DIR}/bin/.classes.jar.dephelper" "${PACKAGE_DIR}/res/values/strings.xml" "${PACKAGE_DIR}/res/drawable/icon.png" ${camera_wrappers} opencv_java
+         DEPENDS "${OpenCV_BINARY_DIR}/bin/classes.jar.dephelper" "${PACKAGE_DIR}/res/values/strings.xml" "${PACKAGE_DIR}/res/drawable/icon.png" ${camera_wrappers} opencv_java
        )
 
 install(FILES "${APK_NAME}" DESTINATION "apk/" COMPONENT main)

android/scripts/camera_build.conf

@@ -16,3 +16,8 @@ native_camera_r4.0.0; armeabi-v7a; 14; /home/alexander/Projects/AndroidSource/4.
 native_camera_r4.1.1; armeabi;     14; /home/alexander/Projects/AndroidSource/4.1.1
 native_camera_r4.1.1; armeabi-v7a; 14; /home/alexander/Projects/AndroidSource/4.1.1
 native_camera_r4.1.1; x86;         14; /home/alexander/Projects/AndroidSource/4.1.1
+native_camera_r4.1.1; mips;        14; /home/alexander/Projects/AndroidSource/4.1.1_mips
+native_camera_r4.2.0; armeabi-v7a; 14; /home/alexander/Projects/AndroidSource/4.2
+native_camera_r4.2.0; armeabi;     14; /home/alexander/Projects/AndroidSource/4.2
+native_camera_r4.2.0; x86;         14; /home/alexander/Projects/AndroidSource/4.2
+native_camera_r4.2.0; mips;        14; /home/alexander/Projects/AndroidSource/4.2

android/scripts/cmake_android_all_cameras.py

@@ -10,11 +10,11 @@ HomeDir = os.getcwd()
 for s in ConfFile.readlines():
     s = s[0:s.find("#")]
     if (not s):
-    continue
+        continue
     keys = s.split(";")
     if (len(keys) < 4):
-    print("Error: invalid config line: \"%s\"" % s)
-    continue
+        print("Error: invalid config line: \"%s\"" % s)
+        continue
     MakeTarget = str.strip(keys[0])
     Arch = str.strip(keys[1])
     NativeApiLevel = str.strip(keys[2])
@@ -22,23 +22,34 @@ for s in ConfFile.readlines():
     AndroidTreeRoot = str.strip(AndroidTreeRoot, "\n")
     print("Building %s for %s" % (MakeTarget, Arch))
     BuildDir = os.path.join(HomeDir, MakeTarget + "_" + Arch)
+
     if (os.path.exists(BuildDir)):
-    shutil.rmtree(BuildDir)
+        shutil.rmtree(BuildDir)
+
     try:
-    os.mkdir(BuildDir)
+        os.mkdir(BuildDir)
     except:
-    print("Error: cannot create direcotry \"%s\"" % BuildDir)
-    continue
+        print("Error: cannot create direcotry \"%s\"" % BuildDir)
+        continue
+
     shutil.rmtree(os.path.join(AndroidTreeRoot, "out", "target", "product", "generic", "system"), ignore_errors=True)
+
+    LinkerLibs = os.path.join(AndroidTreeRoot, "bin_arm", "system")
     if (Arch == "x86"):
-    shutil.copytree(os.path.join(AndroidTreeRoot, "bin_x86", "system"), os.path.join(AndroidTreeRoot, "out", "target", "product", "generic", "system"))
+        LinkerLibs = os.path.join(AndroidTreeRoot, "bin_x86", "system")
     elif (Arch == "mips"):
-    shutil.copytree(os.path.join(AndroidTreeRoot, "bin_mips", "system"), os.path.join(AndroidTreeRoot, "out", "target", "product", "generic", "system"))
-    else:
-    shutil.copytree(os.path.join(AndroidTreeRoot, "bin_arm", "system"), os.path.join(AndroidTreeRoot, "out", "target", "product", "generic", "system"))
+        LinkerLibs = os.path.join(AndroidTreeRoot, "bin_mips", "system")
+
+    if (not os.path.exists(LinkerLibs)):
+        print("Error: Paltform libs for linker in path \"%s\" not found" % LinkerLibs)
+        print("Building %s for %s\t[\033[91mFAILED\033[0m]" % (MakeTarget, Arch))
+        continue
+
+    shutil.copytree(LinkerLibs, os.path.join(AndroidTreeRoot, "out", "target", "product", "generic", "system"))
+
     os.chdir(BuildDir)
     BuildLog = os.path.join(BuildDir, "build.log")
-    CmakeCmdLine = "cmake -DCMAKE_TOOLCHAIN_FILE=../android.toolchain.cmake -DANDROID_SOURCE_TREE=\"%s\" -DANDROID_NATIVE_API_LEVEL=\"%s\" -DANDROID_ABI=\"%s\" -DANDROID_USE_STLPORT=ON ../../ > \"%s\" 2>&1" % (AndroidTreeRoot, NativeApiLevel, Arch, BuildLog)
+    CmakeCmdLine = "cmake -DCMAKE_TOOLCHAIN_FILE=../android.toolchain.cmake -DANDROID_SOURCE_TREE=\"%s\" -DANDROID_NATIVE_API_LEVEL=\"%s\" -DANDROID_ABI=\"%s\" -DANDROID_STL=stlport_static ../../ > \"%s\" 2>&1" % (AndroidTreeRoot, NativeApiLevel, Arch, BuildLog)
     MakeCmdLine = "make %s >> \"%s\" 2>&1" % (MakeTarget, BuildLog);
     #print(CmakeCmdLine)
     os.system(CmakeCmdLine)
@@ -47,12 +58,12 @@ for s in ConfFile.readlines():
     os.chdir(HomeDir)
     CameraLib = os.path.join(BuildDir, "lib", Arch, "lib" + MakeTarget + ".so")
     if (os.path.exists(CameraLib)):
-    try:
-        shutil.copyfile(CameraLib, os.path.join("..", "3rdparty", "lib", Arch, "lib" + MakeTarget + ".so"))
-        print("Building %s for %s\t[\033[92mOK\033[0m]" % (MakeTarget, Arch));
-    except:
-        print("Building %s for %s\t[\033[91mFAILED\033[0m]" % (MakeTarget, Arch));
+        try:
+            shutil.copyfile(CameraLib, os.path.join("..", "3rdparty", "lib", Arch, "lib" + MakeTarget + ".so"))
+            print("Building %s for %s\t[\033[92mOK\033[0m]" % (MakeTarget, Arch));
+        except:
+            print("Building %s for %s\t[\033[91mFAILED\033[0m]" % (MakeTarget, Arch));
     else:
-    print("Building %s for %s\t[\033[91mFAILED\033[0m]" % (MakeTarget, Arch));
-ConfFile.close()
+        print("Building %s for %s\t[\033[91mFAILED\033[0m]" % (MakeTarget, Arch));
 
+ConfFile.close()

android/scripts/cmake_android_service.sh

@@ -4,5 +4,5 @@ cd `dirname $0`/..
 mkdir -p build_service
 cd build_service
 
-cmake -DCMAKE_TOOLCHAIN_FILE=../android.toolchain.cmake -DANDROID_USE_STLPORT=ON -DBUILD_ANDROID_SERVICE=ON -DANDROID_SOURCE_TREE=~/Projects/AndroidSource/2.2.2/ $@ ../..
+cmake -DCMAKE_TOOLCHAIN_FILE=../android.toolchain.cmake -DANDROID_TOOLCHAIN_NAME="arm-linux-androideabi-4.4.3" -DANDROID_STL=stlport_static -DANDROID_STL_FORCE_FEATURES=OFF -DBUILD_ANDROID_SERVICE=ON -DANDROID_SOURCE_TREE=~/Projects/AndroidSource/ServiceStub/ $@ ../..
 

android/service/CMakeLists.txt

@@ -1,2 +1,6 @@
-add_subdirectory(engine)
-#add_subdirectory(engine_test)
+if(BUILD_ANDROID_SERVICE)
+  add_subdirectory(engine)
+  #add_subdirectory(engine_test)
+endif()
+
+install(FILES "readme.txt" DESTINATION "apk/" COMPONENT main)

android/service/ReadMe.txt

@@ -1,22 +0,0 @@
-***************
-Package Content
-***************
-
-The package provides new OpenCV SDK that uses OpenCV Manager for library initialization. OpenCV Manager provides the following benefits:
-
-* Less memory usage. All apps use the same binaries from service and do not keep native libs inside them self;
-* Hardware specific optimizations for all supported platforms;
-* Trusted OpenCV library source. All packages with OpenCV are published on Google Play service;
-* Regular updates and bug fixes;
- 
-Package consists from Library Project for Java development with Eclipse, C++ headers and libraries for native application development, javadoc samples and prebuilt binaries for ARM and X86 platforms.
-To try new SDK on serial device with Google Play just install sample package and follow application messages (Google Play service access will be needed).
-TO start example on device without Google Play you need to install OpenCV manager package and OpenCV binary pack for your platform from apk folder before.
-See docs/doc/tutorials/introduction/android_binary_package/android_binary_package.html and docs/android/refmain.html for details about service.
-On-line documentation will be available at address: http://docs.opencv.org/trunk
-
-********
-Contacts
-********
-
-Please send all feedback to Alexander Smorkalov mailto: alexander.smorkalov@itseez.com

android/service/doc/BaseLoaderCallback.rst

@@ -1,18 +1,20 @@
 *********************************************
-Base Loader Callback Interface implementation
+Base Loader Callback Interface Implementation
 *********************************************
 
 .. highlight:: java
 .. class:: BaseLoaderCallback
 
-    Basic implementation of LoaderCallbackInterface. Logic of this implementation is well-described by the following scheme:
+    Basic implementation of ``LoaderCallbackInterface``. Logic of this implementation is
+    well-described by the following scheme:
 
 .. image:: img/AndroidAppUsageModel.png
 
 Using in Java Activity
 ----------------------
 
-There is a very base code snippet implementing the async initialization with BaseLoaderCallback. See the "15-puzzle" OpenCV sample for details.
+There is a very base code snippet implementing the async initialization with ``BaseLoaderCallback``.
+See the "15-puzzle" OpenCV sample for details.
 
 .. code-block:: java
     :linenos:
@@ -42,7 +44,7 @@ There is a very base code snippet implementing the async initialization with Bas
     @Override
     protected void onResume()
     {
-        Log.i(TAG, "called onResume");
+        Log.i(TAG, "Called onResume");
         super.onResume();
 
         Log.i(TAG, "Trying to load OpenCV library");
@@ -55,6 +57,7 @@ There is a very base code snippet implementing the async initialization with Bas
 Using in Service
 ----------------
 
-Default BaseLoaderCallback implementation treat application context as Activity and calls Activity.finish() method to exit in case of initialization failure.
-To override this behavior you need to override finish() method of BaseLoaderCallback class and implement your own finalization method.
-
+Default ``BaseLoaderCallback`` implementation treats application context as ``Activity`` and calls
+``Activity.finish()`` method to exit in case of initialization failure.
+To override this behavior you need to override ``finish()`` method of ``BaseLoaderCallback`` class
+and implement your own finalization method.

android/service/doc/InstallCallbackInterface.rst

@@ -28,7 +28,7 @@ void cancel()
 
 .. method:: void cancel()
 
-    Installation if package has been canceled.
+    Installation of package has been cancelled.
 
 void wait_install()
 -------------------

android/service/doc/Intro.rst

@@ -7,34 +7,38 @@ Introduction
 
 .. highlight:: java
 
-OpenCV Manager is an Android service targeted to manage OpenCV library binaries on end users devices. It allows sharing the OpenCV dynamic libraries of different versions between applications on the same device. The Manager provides the following benefits\:
+OpenCV Manager is an Android service targeted to manage OpenCV library binaries on end users devices.
+It allows sharing the OpenCV dynamic libraries between applications on the same device. The Manager
+provides the following benefits\:
 
 #. Less memory usage. All apps use the same binaries from service and do not keep native libs inside themselves;
 #. Hardware specific optimizations for all supported platforms;
-#. Trusted OpenCV library source. All packages with OpenCV are published on Google Play service;
+#. Trusted OpenCV library source. All packages with OpenCV are published on Google Play market;
 #. Regular updates and bug fixes;
 
-Usage model for target user
----------------------------
+Usage model for end user
+------------------------
 
 .. image:: img/AndroidAppUsageModel.png
 
 First OpenCV app\:
 
 #. Any OpenCV-dependent app is installed from Google Play marketplace or manually;
-#. At the first launch, it suggests installing OpenCV Manager;
-#. Then OpenCV Manager is downloaded and installed, using Google Play marketplace service.
-#. When Manager has ben started, the application suggests installing OpenCV library for the target device trough Google Play marketplace if it is necessary;
-#. After installation is finished, the app may be launched to perform common tasks.
+#. At the first launch, it suggests installation of OpenCV Manager;
+#. Then OpenCV Manager is downloaded and installed, using the Google Play application.
+#. When Manager has been started, the application suggests installation of OpenCV library for the
+   target device architecture if it is necessary;
+#. After the installation is finished, the app may be launched.
 
-Next OpenCV app\:
+Subsequent launches of OpenCV apps\:
 
-#. Any OpenCV-dependent app is installed from Google Play marketplace or manually;
+#. Any OpenCV-dependent app is installed from Google Play market or manually;
 #. At the first launch, the app starts as usually;
-#. If the selected version is not installed, OpenCV Manager suggests installing OpenCV library for the target device trough Google Play marketplace;
-#. After installation is finished, the app may be launched to perform common tasks.
+#. If the selected OpenCV version is not installed, OpenCV Manager suggests installing OpenCV
+   library for the target device through Google Play marketplace;
+#. After the installation is finished, the app may be launched.
 
-OpenCV Manager structure
-------------------------
+Architecture of OpenCV Manager
+------------------------------
 
 .. image:: img/Structure.png

android/service/doc/JavaHelper.rst

@@ -12,23 +12,27 @@ boolean initDebug()
 
 .. method:: static boolean initDebug()
 
-    Loads and initializes OpenCV library from within current application package. Roughly it is analog of ``system.loadLibrary("opencv_java")``.
+    Loads and initializes OpenCV library from within current application package. Roughly it is
+    analog of ``system.loadLibrary("opencv_java")``.
 
     :rtype: boolean;
     :return: returns true if initialization of OpenCV was successful.
 
-.. note:: This method is deprecated for production code. It is designed for experimantal and local development purposes only. If you want to publish your app use approach with async initialization.
+.. note:: This method is deprecated for production code. It is designed for experimental and local
+          development purposes only. If you want to publish your app use approach with async
+          initialization.
 
 boolean initAsync()
 -------------------
 
 .. method:: static boolean initAsync(String Version, Context AppContext, LoaderCallbackInterface Callback)
 
-    Loads and initializes OpenCV library using OpenCV Manager service.
+    Loads and initializes OpenCV library using OpenCV Manager.
 
     :param Version: OpenCV Library version.
     :param AppContext: application context for connecting to the service.
-    :param Callback: object, that implements LoaderCallbackInterface for handling connection status (see BaseLoaderCallback).
+    :param Callback: object, that implements ``LoaderCallbackInterface`` for handling connection
+                     status (see ``BaseLoaderCallback``).
 
     :rtype: boolean;
     :return: returns true if initialization of OpenCV starts successfully.
@@ -43,10 +47,3 @@ OpenCV version constants
 .. data:: OPENCV_VERSION_2_4_3
 
     OpenCV Library version 2.4.3
-
-Other constatnts
-----------------
-
-.. data:: OPEN_CV_SERVICE_URL
-
-    Url for OpenCV Manager on Google Play (Android Market)

android/service/doc/LoaderCallbackInterface.rst

@@ -12,9 +12,9 @@ void onManagerConnected()
 
 .. method:: void onManagerConnected(int status)
 
-    Callback method that is called after OpenCV Library initialization.
+    Callback method that is called after OpenCV library initialization.
 
-    :param status: status of initialization (see Initialization Status Constants).
+    :param status: status of initialization (see "Initialization Status Constants" section below).
 
 void onPackageInstall()
 -----------------------
@@ -23,7 +23,7 @@ void onPackageInstall()
 
     Callback method that is called in case when package installation is needed.
 
-    :param callback: answer object with approve and cancel methods and package description.
+    :param callback: answer object with ``install`` and ``cancel`` methods and package description.
 
 Initialization status constants
 -------------------------------
@@ -34,15 +34,15 @@ Initialization status constants
 
 .. data:: MARKET_ERROR
 
-    Google Play (Android Market) cannot be invoked
+    Google Play (Android Market) application cannot be invoked
 
 .. data:: INSTALL_CANCELED
 
-    OpenCV library installation was canceled by user
+    OpenCV library installation was cancelled by user
 
 .. data:: INCOMPATIBLE_MANAGER_VERSION
 
-    Version of OpenCV Manager Service is incompatible with this app. Service update is needed
+    Version of OpenCV Manager is incompatible with this app. Manager update is needed.
 
 .. data:: INIT_FAILED
 

android/service/doc/UseCases.rst

@@ -1,6 +1,9 @@
-*******************************************
 Manager Workflow
-*******************************************
+****************
+
+.. _manager_selection:
+
+.. include:: ../readme.txt
 
 First application start
 -----------------------
@@ -9,15 +12,15 @@ There is no OpenCV Manager or OpenCV libraries:
 
 .. image:: img/NoService.png
 
-Aditional library package installation
---------------------------------------
+Additional library package installation
+---------------------------------------
 
-There is an OpenCV Manager service, but there is no apropriate OpenCV library.
+There is an OpenCV Manager service, but it does not contain appropriate OpenCV library.
 If OpenCV library installation has been approved\:
 
 .. image:: img/LibInstallAproved.png
 
-If OpenCV library installation has been canceled\:
+If OpenCV library installation has been cancelled\:
 
 .. image:: img/LibInstallCanceled.png
 

android/service/doc/build_uml.py

@@ -20,4 +20,4 @@ if (not os.path.exists(TARGET_PATH)):
 
 for filename in os.listdir("."):
     if ("dia" == filename[-3:]):
-    os.system("%s --export %s %s" % (DiaPath, os.path.join(TARGET_PATH, filename[0:len(filename)-4] + ".png"), filename))
+        os.system("%s --export %s %s" % (DiaPath, os.path.join(TARGET_PATH, filename[0:len(filename)-4] + ".png"), filename))

android/service/engine/AndroidManifest.xml

@@ -1,10 +1,10 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="org.opencv.engine"
-    android:versionCode="18"
-    android:versionName="1.8" >
+    android:versionCode="25@ANDROID_PLATFORM_VERSION_CODE@"
+    android:versionName="2.5" >
 
-    <uses-sdk android:minSdkVersion="8" />
+    <uses-sdk android:minSdkVersion="@ANDROID_NATIVE_API_LEVEL@" />
     <uses-feature android:name="android.hardware.touchscreen" android:required="false"/>
 
     <application

android/service/engine/CMakeLists.txt

@@ -1,10 +1,38 @@
 set(engine OpenCVEngine)
 set(JNI_LIB_NAME ${engine} ${engine}_jni)
-add_android_project(opencv_engine "${CMAKE_CURRENT_SOURCE_DIR}" SDK_TARGET 8 ${ANDROID_SDK_TARGET} IGNORE_JAVA ON)
 
-link_directories("${ANDROID_SOURCE_TREE}/out/target/product/generic/system/lib" "${ANDROID_SOURCE_TREE}/out/target/product/${ANDROID_PRODUCT}/system/lib" "${ANDROID_SOURCE_TREE}/bin_${ANDROID_ARCH_NAME}/system/lib")
+unset(__android_project_chain CACHE)
+add_android_project(opencv_engine "${CMAKE_CURRENT_SOURCE_DIR}" SDK_TARGET 9 ${ANDROID_SDK_TARGET} IGNORE_JAVA ON IGNORE_MANIFEST ON )
 
-SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-allow-shlib-undefined")
+set(ANDROID_PLATFORM_VERSION_CODE "0")
+
+if(ARMEABI_V7A)
+  if (ANDROID_NATIVE_API_LEVEL LESS 9)
+    set(ANDROID_PLATFORM_VERSION_CODE "2")
+  else()
+    set(ANDROID_PLATFORM_VERSION_CODE "3")
+  endif()
+elseif(ARMEABI_V6)
+  set(ANDROID_PLATFORM_VERSION_CODE "1")
+elseif(ARMEABI)
+  set(ANDROID_PLATFORM_VERSION_CODE "1")
+elseif(X86)
+  set(ANDROID_PLATFORM_VERSION_CODE "4")
+elseif(MIPS)
+  set(ANDROID_PLATFORM_VERSION_CODE "5")
+else()
+  message(WARNING "Can not automatically determine the value for ANDROID_PLATFORM_VERSION_CODE")
+endif()
+
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/${ANDROID_MANIFEST_FILE}" "${OpenCV_BINARY_DIR}/android/service/engine/.build/${ANDROID_MANIFEST_FILE}"  @ONLY)
+
+link_directories("${ANDROID_SOURCE_TREE}/out/target/product/generic/system/lib" "${ANDROID_SOURCE_TREE}/out/target/product/${ANDROID_PRODUCT}/system/lib" "${ANDROID_SOURCE_TREE}/bin/${ANDROID_ARCH_NAME}")
+
+# -D__SUPPORT_ARMEABI_FEATURES key is also available
+add_definitions(-DPLATFORM_ANDROID -D__SUPPORT_ARMEABI_V7A_FEATURES -D__SUPPORT_TEGRA3 -D__SUPPORT_MIPS)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti -fno-exceptions")
+
+set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-allow-shlib-undefined")
 file(GLOB engine_files "jni/BinderComponent/*.cpp" "jni/BinderComponent/*.h" "jni/include/*.h")
 
 include_directories(jni/BinderComponent jni/include)

android/service/engine/build.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project name="ManagerActivity" default="help">
+<project name="OpenCV Manager" default="help">
 
     <!-- The local.properties file is created and updated by the 'android' tool.
          It contains the path to the SDK. It should *NOT* be checked into

android/service/engine/jni/Android.mk

@@ -35,7 +35,7 @@ LOCAL_MODULE := libOpenCVEngine
 
 LOCAL_LDLIBS += -lz -lbinder -llog -lutils
 
-LOCAL_LDFLAGS += -Wl,-allow-shlib-undefine
+LOCAL_LDFLAGS += -Wl,-allow-shlib-undefined
 
 include $(BUILD_SHARED_LIBRARY)
 
@@ -52,7 +52,8 @@ LOCAL_SRC_FILES := \
     NativeService/CommonPackageManager.cpp \
     JNIWrapper/JavaBasedPackageManager.cpp \
     NativeService/PackageInfo.cpp \
-    JNIWrapper/HardwareDetector_jni.cpp
+    JNIWrapper/HardwareDetector_jni.cpp \
+    JNIWrapper/OpenCVLibraryInfo.cpp
 
 LOCAL_C_INCLUDES := \
     $(LOCAL_PATH)/include \
@@ -74,7 +75,6 @@ LOCAL_CFLAGS += -D__SUPPORT_MIPS
 LOCAL_MODULE := libOpenCVEngine_jni
 
 LOCAL_LDLIBS += -lz -lbinder -llog -lutils -landroid_runtime
-
 LOCAL_SHARED_LIBRARIES = libOpenCVEngine
 
 include $(BUILD_SHARED_LIBRARY)
@@ -83,4 +83,4 @@ include $(BUILD_SHARED_LIBRARY)
 #        Native test application
 #---------------------------------------------------------------------
 
-include $(LOCAL_PATH)/Tests/Tests.mk
+#include $(LOCAL_PATH)/Tests/Tests.mk

android/service/engine/jni/Application.mk

@@ -2,4 +2,5 @@ APP_ABI := armeabi x86 mips
 APP_PLATFORM := android-8
 APP_STL := stlport_static
 APP_CPPFLAGS := -fno-rtti -fno-exceptions
+NDK_TOOLCHAIN_VERSION=4.4.3
 #APP_OPTIM := debug

android/service/engine/jni/BinderComponent/OpenCVEngine.cpp

@@ -15,60 +15,44 @@ using namespace android;
 
 const int OpenCVEngine::Platform = DetectKnownPlatforms();
 const int OpenCVEngine::CpuID = GetCpuID();
+const int OpenCVEngine::KnownVersions[] = {2040000, 2040100, 2040200, 2040300, 2040301, 2040302};
 
-std::set<std::string> OpenCVEngine::InitKnownOpenCVersions()
+bool OpenCVEngine::ValidateVersion(int version)
 {
-    std::set<std::string> result;
+    for (size_t i = 0; i < sizeof(KnownVersions)/sizeof(int); i++)
+        if (KnownVersions[i] == version)
+            return true;
 
-    result.insert("240");
-    result.insert("241");
-    result.insert("242");
-    result.insert("243");
-
-    return result;
+    return false;
 }
 
-const std::set<std::string> OpenCVEngine::KnownVersions = InitKnownOpenCVersions();
-
-bool OpenCVEngine::ValidateVersionString(const std::string& version)
+int OpenCVEngine::NormalizeVersionString(std::string version)
 {
-    return (KnownVersions.find(version) != KnownVersions.end());
-}
-
-std::string OpenCVEngine::NormalizeVersionString(std::string version)
-{
-    std::string result = "";
-    std::string suffix = "";
+    int result = 0;
 
     if (version.empty())
     {
         return result;
     }
 
-    if (('a' == version[version.size()-1]) || ('b' == version[version.size()-1]))
-    {
-        suffix = version[version.size()-1];
-        version.erase(version.size()-1);
-    }
-
     std::vector<std::string> parts = SplitStringVector(version, '.');
 
-    if (parts.size() >= 2)
+    // Use only 4 digits of the version, i.e. 1.2.3.4.
+    // Other digits will be ignored.
+    if (parts.size() > 4)
+        parts.erase(parts.begin()+4, parts.end());
+
+    int multiplyer = 1000000;
+    for (std::vector<std::string>::const_iterator it = parts.begin(); it != parts.end(); ++it)
     {
-        if (parts.size() >= 3)
-        {
-            result = parts[0] + parts[1] + parts[2] + suffix;
-            if (!ValidateVersionString(result))
-                result = "";
-        }
-        else
-        {
-            result = parts[0] + parts[1] + "0" + suffix;
-            if (!ValidateVersionString(result))
-                result = "";
-        }
+        int digit = atoi(it->c_str());
+        result += multiplyer*digit;
+        multiplyer /= 100;
     }
 
+    if (!ValidateVersion(result))
+        result  = 0;
+
     return result;
 }
 
@@ -86,19 +70,19 @@ int32_t OpenCVEngine::GetVersion()
 String16 OpenCVEngine::GetLibPathByVersion(android::String16 version)
 {
     std::string std_version(String8(version).string());
-    std::string norm_version;
+    int norm_version;
     std::string path;
 
     LOGD("OpenCVEngine::GetLibPathByVersion(%s) impl", String8(version).string());
 
     norm_version = NormalizeVersionString(std_version);
 
-    if (!norm_version.empty())
+    if (0 != norm_version)
     {
         path = PackageManager->GetPackagePathByVersion(norm_version, Platform, CpuID);
         if (path.empty())
         {
-            LOGI("Package OpenCV of version %s is not installed. Try to install it :)", norm_version.c_str());
+            LOGI("Package OpenCV of version \"%s\" (%d) is not installed. Try to install it :)", String8(version).string(), norm_version);
         }
         else
         {
@@ -107,7 +91,7 @@ String16 OpenCVEngine::GetLibPathByVersion(android::String16 version)
     }
     else
     {
-        LOGE("OpenCV version \"%s\" (%s) is not supported", String8(version).string(), norm_version.c_str());
+        LOGE("OpenCV version \"%s\" (%d) is not supported", String8(version).string(), norm_version);
     }
 
     return String16(path.c_str());
@@ -116,11 +100,11 @@ String16 OpenCVEngine::GetLibPathByVersion(android::String16 version)
 android::String16 OpenCVEngine::GetLibraryList(android::String16 version)
 {
     std::string std_version = String8(version).string();
-    std::string norm_version;
+    int norm_version;
     String16 result;
     norm_version = NormalizeVersionString(std_version);
 
-    if (!norm_version.empty())
+    if (0 != norm_version)
     {
         std::string tmp = PackageManager->GetPackagePathByVersion(norm_version, Platform, CpuID);
         if (!tmp.empty())
@@ -130,7 +114,7 @@ android::String16 OpenCVEngine::GetLibraryList(android::String16 version)
             LOGD("Trying to load info library \"%s\"", tmp.c_str());
 
             void* handle;
-            char* (*info_func)();
+            InfoFunctionType info_func;
 
             handle = dlopen(tmp.c_str(), RTLD_LAZY);
             if (handle)
@@ -138,7 +122,7 @@ android::String16 OpenCVEngine::GetLibraryList(android::String16 version)
                 const char* error;
 
                 dlerror();
-                *(void **) (&info_func) = dlsym(handle, "GetLibraryList");
+                info_func = (InfoFunctionType)dlsym(handle, "GetLibraryList");
                 if ((error = dlerror()) == NULL)
                 {
                     result = String16((*info_func)());
@@ -156,12 +140,12 @@ android::String16 OpenCVEngine::GetLibraryList(android::String16 version)
         }
         else
         {
-            LOGI("Package OpenCV of version %s is not installed. Try to install it :)", norm_version.c_str());
+            LOGI("Package OpenCV of version \"%s\" (%d) is not installed. Try to install it :)", std_version.c_str(), norm_version);
         }
     }
     else
     {
-        LOGE("OpenCV version \"%s\" is not supported", norm_version.c_str());
+        LOGE("OpenCV version \"%s\" is not supported", std_version.c_str());
     }
 
     return result;
@@ -170,21 +154,21 @@ android::String16 OpenCVEngine::GetLibraryList(android::String16 version)
 bool OpenCVEngine::InstallVersion(android::String16 version)
 {
     std::string std_version = String8(version).string();
-    std::string norm_version;
+    int norm_version;
     bool result = false;
 
     LOGD("OpenCVEngine::InstallVersion() begin");
 
     norm_version = NormalizeVersionString(std_version);
 
-    if (!norm_version.empty())
+    if (0 != norm_version)
     {
         LOGD("PackageManager->InstallVersion call");
         result = PackageManager->InstallVersion(norm_version, Platform, CpuID);
     }
     else
     {
-        LOGE("OpenCV version \"%s\" is not supported", norm_version.c_str());
+        LOGE("OpenCV version \"%s\" (%d) is not supported", std_version.c_str(), norm_version);
     }
 
     LOGD("OpenCVEngine::InstallVersion() end");

android/service/engine/jni/BinderComponent/OpenCVEngine.h

@@ -23,16 +23,15 @@ public:
 
 protected:
     IPackageManager* PackageManager;
-    static const std::set<std::string> KnownVersions;
+    static const int KnownVersions[];
 
     OpenCVEngine();
-    static std::set<std::string> InitKnownOpenCVersions();
-    bool ValidateVersionString(const std::string& version);
-    std::string NormalizeVersionString(std::string version);
+    bool ValidateVersion(int version);
+    int NormalizeVersionString(std::string version);
     bool FixPermissions(const std::string& path);
 
     static const int Platform;
     static const int CpuID;
 };
 
-#endif
+#endif

android/service/engine/jni/JNIWrapper/HardwareDetector_jni.cpp

@@ -3,7 +3,7 @@
 #include <jni.h>
 #include <string>
 
-JNIEXPORT jint JNICALL Java_org_opencv_engine_HardwareDetector_GetCpuID(JNIEnv* env, jclass)
+JNIEXPORT jint JNICALL Java_org_opencv_engine_HardwareDetector_GetCpuID(JNIEnv* , jclass)
 {
     return GetCpuID();
 }
@@ -14,12 +14,12 @@ JNIEXPORT jstring JNICALL Java_org_opencv_engine_HardwareDetector_GetPlatformNam
     return env->NewStringUTF(hardware_name.c_str());
 }
 
-JNIEXPORT jint JNICALL Java_org_opencv_engine_HardwareDetector_GetProcessorCount(JNIEnv* env, jclass)
+JNIEXPORT jint JNICALL Java_org_opencv_engine_HardwareDetector_GetProcessorCount(JNIEnv* , jclass)
 {
     return GetProcessorCount();
 }
 
-JNIEXPORT jint JNICALL Java_org_opencv_engine_HardwareDetector_DetectKnownPlatforms(JNIEnv* env, jclass)
+JNIEXPORT jint JNICALL Java_org_opencv_engine_HardwareDetector_DetectKnownPlatforms(JNIEnv* , jclass)
 {
     return DetectKnownPlatforms();
 }

android/service/engine/jni/JNIWrapper/JavaBasedPackageManager.cpp

@@ -46,7 +46,9 @@ bool JavaBasedPackageManager::InstallPackage(const PackageInfo& package)
     LOGD("Calling java package manager with package name %s\n", package.GetFullName().c_str());
     jobject jpkgname = jenv->NewStringUTF(package.GetFullName().c_str());
     bool result = jenv->CallNonvirtualBooleanMethod(JavaPackageManager, jclazz, jmethod, jpkgname);
+
     jenv->DeleteLocalRef(jpkgname);
+    jenv->DeleteLocalRef(jclazz);
 
     if (self_attached)
     {
@@ -104,9 +106,12 @@ vector<PackageInfo> JavaBasedPackageManager::GetInstalledPackages()
 
         if (tmp.IsValid())
             result.push_back(tmp);
+
+        jenv->DeleteLocalRef(jtmp);
     }
 
     jenv->DeleteLocalRef(jpkgs);
+    jenv->DeleteLocalRef(jclazz);
 
     if (self_attached)
     {
@@ -118,6 +123,16 @@ vector<PackageInfo> JavaBasedPackageManager::GetInstalledPackages()
     return result;
 }
 
+static jint GetAndroidVersion(JNIEnv* jenv)
+{
+    jclass jclazz = jenv->FindClass("android/os/Build$VERSION");
+    jfieldID jfield = jenv->GetStaticFieldID(jclazz, "SDK_INT", "I");
+    jint api_level = jenv->GetStaticIntField(jclazz, jfield);
+    jenv->DeleteLocalRef(jclazz);
+
+    return api_level;
+}
+
 // IMPORTANT: This method can be called only if thread is attached to Dalvik
 PackageInfo JavaBasedPackageManager::ConvertPackageFromJava(jobject package, JNIEnv* jenv)
 {
@@ -133,23 +148,27 @@ PackageInfo JavaBasedPackageManager::ConvertPackageFromJava(jobject package, JNI
     const char* jversionstr = jenv->GetStringUTFChars(jversionobj, NULL);
     string verison(jversionstr);
     jenv->DeleteLocalRef(jversionobj);
+    jenv->DeleteLocalRef(jclazz);
 
+    static const jint api_level = GetAndroidVersion(jenv);
     string path;
-    jclazz = jenv->FindClass("android/os/Build$VERSION");
-    jfield = jenv->GetStaticFieldID(jclazz, "SDK_INT", "I");
-    jint api_level = jenv->GetStaticIntField(jclazz, jfield);
     if (api_level > 8)
     {
         jclazz = jenv->GetObjectClass(package);
         jfield = jenv->GetFieldID(jclazz, "applicationInfo", "Landroid/content/pm/ApplicationInfo;");
         jobject japp_info = jenv->GetObjectField(package, jfield);
+        jenv->DeleteLocalRef(jclazz);
+
         jclazz = jenv->GetObjectClass(japp_info);
         jfield = jenv->GetFieldID(jclazz, "nativeLibraryDir", "Ljava/lang/String;");
         jstring jpathobj = static_cast<jstring>(jenv->GetObjectField(japp_info, jfield));
         const char* jpathstr = jenv->GetStringUTFChars(jpathobj, NULL);
         path = string(jpathstr);
         jenv->ReleaseStringUTFChars(jpathobj, jpathstr);
+
+        jenv->DeleteLocalRef(japp_info);
         jenv->DeleteLocalRef(jpathobj);
+        jenv->DeleteLocalRef(jclazz);
     }
     else
     {

android/service/engine/jni/JNIWrapper/JavaBasedPackageManager.h

@@ -19,4 +19,4 @@ private:
 
     JavaBasedPackageManager();
     PackageInfo ConvertPackageFromJava(jobject package, JNIEnv* jenv);
-};
+};

android/service/engine/jni/JNIWrapper/OpenCVEngine_jni.cpp

@@ -30,7 +30,7 @@ JNIEXPORT jobject JNICALL Java_org_opencv_engine_BinderConnector_Connect(JNIEnv*
     return javaObjectForIBinder(env, OpenCVEngineBinder);
 }
 
-JNIEXPORT jboolean JNICALL Java_org_opencv_engine_BinderConnector_Init(JNIEnv* env, jobject thiz, jobject market)
+JNIEXPORT jboolean JNICALL Java_org_opencv_engine_BinderConnector_Init(JNIEnv* env, jobject , jobject market)
 {
     LOGD("Java_org_opencv_engine_BinderConnector_Init");
 

android/service/engine/jni/JNIWrapper/OpenCVLibraryInfo.cpp

@@ -0,0 +1,88 @@
+#include "OpenCVLibraryInfo.h"
+#include "EngineCommon.h"
+#include <utils/Log.h>
+#include <dlfcn.h>
+
+JNIEXPORT jlong JNICALL Java_org_opencv_engine_OpenCVLibraryInfo_open
+  (JNIEnv * env, jobject, jstring str)
+{
+    const char* infoLibPath = env->GetStringUTFChars(str, NULL);
+    if (infoLibPath == NULL)
+        return 0;
+
+    LOGD("Trying to load info library \"%s\"", infoLibPath);
+
+    void* handle;
+
+    handle = dlopen(infoLibPath, RTLD_LAZY);
+    if (handle == NULL)
+        LOGI("Info library not found by path \"%s\"", infoLibPath);
+
+    return (jlong)handle;
+}
+
+JNIEXPORT jstring JNICALL Java_org_opencv_engine_OpenCVLibraryInfo_getPackageName
+  (JNIEnv* env, jobject, jlong handle)
+{
+    InfoFunctionType info_func;
+    const char* result;
+    const char* error;
+
+    dlerror();
+    info_func = (InfoFunctionType)dlsym((void*)handle, "GetPackageName");
+    if ((error = dlerror()) == NULL)
+        result = (*info_func)();
+    else
+    {
+        LOGE("dlsym error: \"%s\"", error);
+        result = "unknown";
+    }
+
+    return env->NewStringUTF(result);
+}
+
+JNIEXPORT jstring JNICALL Java_org_opencv_engine_OpenCVLibraryInfo_getLibraryList
+  (JNIEnv* env, jobject, jlong handle)
+{
+    InfoFunctionType info_func;
+    const char* result;
+    const char* error;
+
+    dlerror();
+    info_func = (InfoFunctionType)dlsym((void*)handle, "GetLibraryList");
+    if ((error = dlerror()) == NULL)
+        result = (*info_func)();
+    else
+    {
+        LOGE("dlsym error: \"%s\"", error);
+        result = "unknown";
+    }
+
+    return env->NewStringUTF(result);
+}
+
+JNIEXPORT jstring JNICALL Java_org_opencv_engine_OpenCVLibraryInfo_getVersionName
+  (JNIEnv* env, jobject, jlong handle)
+{
+    InfoFunctionType info_func;
+    const char* result;
+    const char* error;
+
+    dlerror();
+    info_func = (InfoFunctionType)dlsym((void*)handle, "GetRevision");
+    if ((error = dlerror()) == NULL)
+        result = (*info_func)();
+    else
+    {
+        LOGE("dlsym error: \"%s\"", error);
+        result = "unknown";
+    }
+
+    return env->NewStringUTF(result);
+}
+
+JNIEXPORT void JNICALL Java_org_opencv_engine_OpenCVLibraryInfo_close
+  (JNIEnv*, jobject, jlong handle)
+{
+    dlclose((void*)handle);
+}

android/service/engine/jni/JNIWrapper/OpenCVLibraryInfo.h

@@ -0,0 +1,27 @@
+#include <jni.h>
+
+#ifndef _Included_org_opencv_engine_OpenCVLibraryInfo
+#define _Included_org_opencv_engine_OpenCVLibraryInfo
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+JNIEXPORT jlong JNICALL Java_org_opencv_engine_OpenCVLibraryInfo_open
+  (JNIEnv *, jobject, jstring);
+
+JNIEXPORT jstring JNICALL Java_org_opencv_engine_OpenCVLibraryInfo_getPackageName
+  (JNIEnv *, jobject, jlong);
+
+JNIEXPORT jstring JNICALL Java_org_opencv_engine_OpenCVLibraryInfo_getLibraryList
+  (JNIEnv *, jobject, jlong);
+
+JNIEXPORT jstring JNICALL Java_org_opencv_engine_OpenCVLibraryInfo_getVersionName
+  (JNIEnv *, jobject, jlong);
+
+JNIEXPORT void JNICALL Java_org_opencv_engine_OpenCVLibraryInfo_close
+  (JNIEnv *, jobject, jlong);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

android/service/engine/jni/NativeService/CommonPackageManager.cpp

@@ -11,22 +11,24 @@
 
 using namespace std;
 
-set<string> CommonPackageManager::GetInstalledVersions()
+vector<int> CommonPackageManager::GetInstalledVersions()
 {
-    set<string> result;
+    vector<int> result;
     vector<PackageInfo> installed_packages = GetInstalledPackages();
 
-    for (vector<PackageInfo>::const_iterator it = installed_packages.begin(); it != installed_packages.end(); ++it)
+    result.resize(installed_packages.size());
+
+    for (size_t i = 0; i < installed_packages.size(); i++)
     {
-        string version = it->GetVersion();
-        assert(!version.empty());
-        result.insert(version);
+        int version = installed_packages[i].GetVersion();
+        assert(version);
+        result[i] = version;
     }
 
     return result;
 }
 
-bool CommonPackageManager::CheckVersionInstalled(const std::string& version, int platform, int cpu_id)
+bool CommonPackageManager::CheckVersionInstalled(int version, int platform, int cpu_id)
 {
     bool result = false;
     LOGD("CommonPackageManager::CheckVersionInstalled() begin");
@@ -48,14 +50,14 @@ bool CommonPackageManager::CheckVersionInstalled(const std::string& version, int
     return result;
 }
 
-bool CommonPackageManager::InstallVersion(const std::string& version, int platform, int cpu_id)
+bool CommonPackageManager::InstallVersion(int version, int platform, int cpu_id)
 {
     LOGD("CommonPackageManager::InstallVersion() begin");
     PackageInfo package(version, platform, cpu_id);
     return InstallPackage(package);
 }
 
-string CommonPackageManager::GetPackagePathByVersion(const std::string& version, int platform, int cpu_id)
+string CommonPackageManager::GetPackagePathByVersion(int version, int platform, int cpu_id)
 {
     string result;
     PackageInfo target_package(version, platform, cpu_id);
@@ -64,7 +66,7 @@ string CommonPackageManager::GetPackagePathByVersion(const std::string& version,
 
     for (vector<PackageInfo>::iterator it = all_packages.begin(); it != all_packages.end(); ++it)
     {
-        LOGD("Check version \"%s\" compatibility with \"%s\"\n", version.c_str(), it->GetVersion().c_str());
+        LOGD("Check version \"%d\" compatibility with \"%d\"\n", version, it->GetVersion());
         if (IsVersionCompatible(version, it->GetVersion()))
         {
             LOGD("Compatible");
@@ -78,49 +80,45 @@ string CommonPackageManager::GetPackagePathByVersion(const std::string& version,
 
     if (!packages.empty())
     {
-        vector<PackageInfo>::iterator found = find(packages.begin(), packages.end(), target_package);
-        if (packages.end() != found)
+        int OptRating = -1;
+        int OptVersion = 0;
+        std::vector<std::pair<int, int> >& group = CommonPackageManager::ArmRating;
+
+        if ((cpu_id & ARCH_X86) || (cpu_id & ARCH_X64))
+            group = CommonPackageManager::IntelRating;
+
+        int HardwareRating = GetHardwareRating(platform, cpu_id, group);
+        LOGD("Current hardware platform rating %d for (%d,%d)", HardwareRating, platform, cpu_id);
+
+        if (-1 == HardwareRating)
         {
-            result = found->GetInstalationPath();
+            LOGE("Cannot calculate rating for current hardware platform!");
         }
         else
         {
-            int OptRating = -1;
-            std::vector<std::pair<int, int> >& group = CommonPackageManager::ArmRating;
-
-            if ((cpu_id & ARCH_X86) || (cpu_id & ARCH_X64))
-                group = CommonPackageManager::IntelRating;
-
-            int HardwareRating = GetHardwareRating(platform, cpu_id, group);
-            LOGD("Current hardware platform %d, %d", platform, cpu_id);
-
-            if (-1 == HardwareRating)
+            vector<PackageInfo>::iterator found = packages.end();
+            for (vector<PackageInfo>::iterator it = packages.begin(); it != packages.end(); ++it)
             {
-                LOGE("Cannot calculate rating for current hardware platform!");
+                int PackageRating = GetHardwareRating(it->GetPlatform(), it->GetCpuID(), group);
+                LOGD("Package \"%s\" rating %d for (%d,%d)", it->GetFullName().c_str(), PackageRating, it->GetPlatform(), it->GetCpuID());
+                if ((PackageRating >= 0) && (PackageRating <= HardwareRating))
+                {
+                    if (((it->GetVersion() >= OptVersion) && (PackageRating >= OptRating)) || (it->GetVersion() > OptVersion))
+                    {
+                        OptRating = PackageRating;
+                        OptVersion = it->GetVersion();
+                        found = it;
+                    }
+                }
+            }
+
+            if ((-1 != OptRating) && (packages.end() != found))
+            {
+                result = found->GetInstalationPath();
             }
             else
             {
-                for (vector<PackageInfo>::iterator it = packages.begin(); it != packages.end(); ++it)
-                {
-                    int PackageRating = GetHardwareRating(it->GetPlatform(), it->GetCpuID(), group);
-                    if (PackageRating >= 0)
-                    {
-                        if ((PackageRating <= HardwareRating) && (PackageRating > OptRating))
-                        {
-                            OptRating = PackageRating;
-                            found = it;
-                        }
-                    }
-                }
-
-                if ((-1 != OptRating) && (packages.end() != found))
-                {
-                    result = found->GetInstalationPath();
-                }
-                else
-                {
-                    LOGI("Found package is incompatible with current hardware platform");
-                }
+                LOGI("Found package is incompatible with current hardware platform");
             }
         }
     }
@@ -128,33 +126,34 @@ string CommonPackageManager::GetPackagePathByVersion(const std::string& version,
     return result;
 }
 
-bool CommonPackageManager::IsVersionCompatible(const std::string& target_version, const std::string& package_version)
+bool CommonPackageManager::IsVersionCompatible(int target_version, int package_version)
 {
-    assert (target_version.size() == 3);
-    assert (package_version.size() == 3);
-
-    bool result = false;
+    assert(target_version);
+    assert(package_version);
 
     // major version is the same and minor package version is above or the same as target.
-    if ((package_version[0] == target_version[0]) && (package_version[1] == target_version[1]) && (package_version[2] >= target_version[2]))
-    {
-    result = true;
-    }
-
-    return result;
+    return ( (package_version/10000 == target_version/10000) && (package_version%10000 >= target_version%10000) );
 }
 
 int CommonPackageManager::GetHardwareRating(int platform, int cpu_id, const std::vector<std::pair<int, int> >& group)
 {
     int result = -1;
 
-    for (size_t i = 0; i < group.size(); i++)
+    if ((cpu_id & ARCH_X86) || (cpu_id & ARCH_X64) || (cpu_id & ARCH_MIPS))
+        // Note: No raiting for x86, x64 and MIPS
+        // only one package is used
+        result = 0;
+    else
     {
-    if (group[i] == std::pair<int, int>(platform, cpu_id))
-    {
-        result = i;
-        break;
-    }
+        // Calculate rating for Arm
+        for (size_t i = 0; i < group.size(); i++)
+        {
+            if (group[i] == std::pair<int, int>(platform, cpu_id))
+            {
+                result = i;
+                break;
+            }
+        }
     }
 
     return result;
@@ -171,14 +170,14 @@ std::vector<std::pair<int, int> > CommonPackageManager::InitArmRating()
     result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_ARMv6 | FEATURES_HAS_VFPv3 | FEATURES_HAS_VFPv3d16));
     result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_ARMv7));
     result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_VFPv3d16));
+    result.push_back(std::pair<int, int>(PLATFORM_TEGRA2,  ARCH_ARMv7 | FEATURES_HAS_VFPv3d16));
     result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_VFPv3));
     result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_VFPv3d16 | FEATURES_HAS_VFPv3));
     result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_NEON));
     result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_VFPv3d16 | FEATURES_HAS_NEON));
     result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_VFPv3 | FEATURES_HAS_NEON));
     result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_VFPv3 | FEATURES_HAS_VFPv3d16 | FEATURES_HAS_NEON));
-    result.push_back(std::pair<int, int>(PLATFORM_TEGRA2, ARCH_ARMv7 | FEATURES_HAS_VFPv3d16));
-    result.push_back(std::pair<int, int>(PLATFORM_TEGRA3, ARCH_ARMv7 | FEATURES_HAS_VFPv3 | FEATURES_HAS_NEON));
+    result.push_back(std::pair<int, int>(PLATFORM_TEGRA3,  ARCH_ARMv7 | FEATURES_HAS_VFPv3 | FEATURES_HAS_NEON));
 
     return result;
 }

android/service/engine/jni/NativeService/CommonPackageManager.h

@@ -3,17 +3,16 @@
 
 #include "IPackageManager.h"
 #include "PackageInfo.h"
-#include <set>
 #include <vector>
 #include <string>
 
 class CommonPackageManager: public IPackageManager
 {
 public:
-    std::set<std::string> GetInstalledVersions();
-    bool CheckVersionInstalled(const std::string& version, int platform, int cpu_id);
-    bool InstallVersion(const std::string& version, int platform, int cpu_id);
-    std::string GetPackagePathByVersion(const std::string& version, int platform, int cpu_id);
+    std::vector<int> GetInstalledVersions();
+    bool CheckVersionInstalled(int version, int platform, int cpu_id);
+    bool InstallVersion(int version, int platform, int cpu_id);
+    std::string GetPackagePathByVersion(int version, int platform, int cpu_id);
     virtual ~CommonPackageManager();
 
 protected:
@@ -23,7 +22,7 @@ protected:
     static std::vector<std::pair<int, int> > InitArmRating();
     static std::vector<std::pair<int, int> > InitIntelRating();
 
-    bool IsVersionCompatible(const std::string& target_version, const std::string& package_version);
+    bool IsVersionCompatible(int target_version, int package_version);
     int GetHardwareRating(int platform, int cpu_id, const std::vector<std::pair<int, int> >& group);
 
     virtual bool InstallPackage(const PackageInfo& package) = 0;
@@ -31,4 +30,4 @@ protected:
 };
 
 
-#endif
+#endif

android/service/engine/jni/NativeService/PackageInfo.cpp

@@ -124,14 +124,19 @@ inline int SplitIntelFeatures(const vector<string>& features)
     return result;
 }
 
-inline string SplitVersion(const vector<string>& features, const string& package_version)
+inline int SplitVersion(const vector<string>& features, const string& package_version)
 {
-    string result;
+    int result = 0;
 
     if ((features.size() > 1) && ('v' == features[1][0]))
     {
-        result = features[1].substr(1);
-        result += SplitStringVector(package_version, '.')[0];
+        // Taking major and minor mart of library version from package name
+        string tmp1 = features[1].substr(1);
+        result += atoi(tmp1.substr(0,1).c_str())*1000000 + atoi(tmp1.substr(1,1).c_str())*10000;
+
+        // Taking release and build number from package revision
+        vector<string> tmp2 = SplitStringVector(package_version, '.');
+        result += atoi(tmp2[0].c_str())*100 + atoi(tmp2[1].c_str());
     }
     else
     {
@@ -186,9 +191,9 @@ inline int SplitPlatfrom(const vector<string>& features)
  * Second part is version. Version starts from "v" symbol. After "v" symbol version nomber without dot symbol added.
  * If platform is known third part is platform name
  * If platform is unknown it is defined by hardware capabilities using pattern: <arch>_<floating point and vectorization features>_<other features>
- * Example: armv7_neon, armv5_vfpv3
+ * Example: armv7_neon
  */
-PackageInfo::PackageInfo(const string& version, int platform, int cpu_id, std::string install_path):
+PackageInfo::PackageInfo(int version, int platform, int cpu_id, std::string install_path):
 Version(version),
 Platform(platform),
 CpuID(cpu_id),
@@ -197,7 +202,15 @@ InstallPath("")
     #ifndef __SUPPORT_TEGRA3
     Platform = PLATFORM_UNKNOWN;
     #endif
-    FullName = BasePackageName + "_v" + Version.substr(0, Version.size()-1);
+
+    int major_version = version/1000000;
+    int minor_version = version/10000 - major_version*100;
+
+    char tmp[32];
+
+    sprintf(tmp, "%d%d", major_version, minor_version);
+
+    FullName = BasePackageName + std::string("_v") + std::string(tmp);
     if (PLATFORM_UNKNOWN != Platform)
     {
         FullName += string("_") + JoinPlatform(platform);
@@ -295,7 +308,7 @@ InstallPath("")
             else
             {
                 LOGD("PackageInfo::PackageInfo: package arch unknown");
-                Version.clear();
+                Version = 0;
                 CpuID = ARCH_UNKNOWN;
                 Platform = PLATFORM_UNKNOWN;
             }
@@ -303,7 +316,7 @@ InstallPath("")
         else
         {
             LOGD("PackageInfo::PackageInfo: package arch unknown");
-            Version.clear();
+            Version = 0;
             CpuID = ARCH_UNKNOWN;
             Platform = PLATFORM_UNKNOWN;
         }
@@ -341,8 +354,8 @@ InstallPath(install_path)
         LOGD("Trying to load info library \"%s\"", tmp.c_str());
 
             void* handle;
-            const char* (*name_func)();
-            const char* (*revision_func)();
+            InfoFunctionType name_func;
+            InfoFunctionType revision_func;
 
             handle = dlopen(tmp.c_str(), RTLD_LAZY);
             if (handle)
@@ -350,8 +363,8 @@ InstallPath(install_path)
                 const char* error;
 
                 dlerror();
-                *(void **) (&name_func) = dlsym(handle, "GetPackageName");
-                *(void **) (&revision_func) = dlsym(handle, "GetRevision");
+                name_func = (InfoFunctionType)dlsym(handle, "GetPackageName");
+                revision_func = (InfoFunctionType)dlsym(handle, "GetRevision");
                 error = dlerror();
 
                 if (!error && revision_func && name_func)
@@ -363,14 +376,14 @@ InstallPath(install_path)
                 }
                 else
                 {
-                    LOGE("Library loading error (%x, %x): \"%s\"", name_func, revision_func, error);
+                    LOGE("Library loading error (%p, %p): \"%s\"", name_func, revision_func, error);
                 }
             }
             else
             {
                 LOGI("Info library not found in package");
                 LOGI("OpenCV Manager package does not contain any verison of OpenCV library");
-                Version.clear();
+                Version = 0;
                 CpuID = ARCH_UNKNOWN;
                 Platform = PLATFORM_UNKNOWN;
                 return;
@@ -382,7 +395,7 @@ InstallPath(install_path)
     if (!features.empty() && (BasePackageName == features[0]))
     {
         Version = SplitVersion(features, package_version);
-        if (Version.empty())
+        if (0 == Version)
         {
             CpuID = ARCH_UNKNOWN;
             Platform = PLATFORM_UNKNOWN;
@@ -392,14 +405,24 @@ InstallPath(install_path)
         Platform = SplitPlatfrom(features);
         if (PLATFORM_UNKNOWN != Platform)
         {
-            CpuID = 0;
+            switch (Platform)
+            {
+                case PLATFORM_TEGRA2:
+                {
+                    CpuID = ARCH_ARMv7 | FEATURES_HAS_VFPv3d16;
+                } break;
+                case PLATFORM_TEGRA3:
+                {
+                    CpuID = ARCH_ARMv7 | FEATURES_HAS_VFPv3 | FEATURES_HAS_NEON;
+                } break;
+            }
         }
         else
         {
             if (features.size() < 3)
             {
                 LOGD("It is not OpenCV library package for this platform");
-                Version.clear();
+                Version = 0;
                 CpuID = ARCH_UNKNOWN;
                 Platform = PLATFORM_UNKNOWN;
                 return;
@@ -433,7 +456,7 @@ InstallPath(install_path)
             else
             {
                 LOGD("It is not OpenCV library package for this platform");
-                Version.clear();
+                Version = 0;
                 CpuID = ARCH_UNKNOWN;
                 Platform = PLATFORM_UNKNOWN;
                 return;
@@ -443,7 +466,7 @@ InstallPath(install_path)
     else
     {
         LOGD("It is not OpenCV library package for this platform");
-        Version.clear();
+        Version = 0;
         CpuID = ARCH_UNKNOWN;
         Platform = PLATFORM_UNKNOWN;
         return;
@@ -452,7 +475,7 @@ InstallPath(install_path)
 
 bool PackageInfo::IsValid() const
 {
-    return !(Version.empty() && (PLATFORM_UNKNOWN == Platform) && (ARCH_UNKNOWN == CpuID));
+    return !((0 == Version) && (PLATFORM_UNKNOWN == Platform) && (ARCH_UNKNOWN == CpuID));
 }
 
 int PackageInfo::GetPlatform() const
@@ -470,7 +493,7 @@ string PackageInfo::GetFullName() const
     return FullName;
 }
 
-string PackageInfo::GetVersion() const
+int PackageInfo::GetVersion() const
 {
     return Version;
 }
@@ -483,4 +506,4 @@ string PackageInfo::GetInstalationPath() const
 bool PackageInfo::operator==(const PackageInfo& package) const
 {
     return (package.FullName == FullName);
-}
+}

android/service/engine/jni/NativeService/PackageInfo.h

@@ -30,10 +30,10 @@
 class PackageInfo
 {
 public:
-    PackageInfo(const std::string& version, int platform, int cpu_id, std::string install_path = "/data/data/");
+    PackageInfo(int version, int platform, int cpu_id, std::string install_path = "/data/data/");
     PackageInfo(const std::string& fullname, const std::string& install_path, std::string package_version = "0.0");
     std::string GetFullName() const;
-    std::string GetVersion() const;
+    int GetVersion() const;
     int GetPlatform() const;
     int GetCpuID() const;
     std::string GetInstalationPath() const;
@@ -43,7 +43,7 @@ public:
 
 protected:
     static std::map<int, std::string> InitPlatformNameMap();
-    std::string Version;
+    int Version;
     int Platform;
     int CpuID;
     std::string FullName;
@@ -51,4 +51,4 @@ protected:
     static const std::string BasePackageName;
 };
 
-#endif
+#endif

android/service/engine/jni/Tests/Tests.mk

@@ -36,7 +36,7 @@ LOCAL_CFLAGS += -D__SUPPORT_TEGRA3
 LOCAL_CFLAGS += -D__SUPPORT_MIPS
 #LOCAL_CFLAGS += -D__SUPPORT_ARMEABI_FEATURES
 
-LOCAL_LDFLAGS = -Wl,-allow-shlib-undefined
+#LOCAL_LDFLAGS = -Wl,-allow-shlib-undefined
 
 LOCAL_MODULE := OpenCVEngineTestApp
 

android/service/engine/jni/include/EngineCommon.h

@@ -5,10 +5,18 @@
 #undef LOG_TAG
 #define LOG_TAG "OpenCVEngine"
 
+// OpenCV Engine API version
 #ifndef OPEN_CV_ENGINE_VERSION
-    #define OPEN_CV_ENGINE_VERSION 1
+    #define OPEN_CV_ENGINE_VERSION 2
 #endif
 
 #define LIB_OPENCV_INFO_NAME "libopencv_info.so"
 
+// OpenCV Manager package name
+#define OPENCV_ENGINE_PACKAGE "org.opencv.engine"
+// Class name of OpenCV engine binder object. Is needned for connection to service
+#define OPECV_ENGINE_CLASSNAME "org.opencv.engine.OpenCVEngineInterface"
+
+typedef const char* (*InfoFunctionType)();
+
 #endif

android/service/engine/jni/include/IOpenCVEngine.h

@@ -4,11 +4,7 @@
 #include <binder/IInterface.h>
 #include <binder/Parcel.h>
 #include <utils/String16.h>
-
-// OpenCV Manager package name
-#define OPENCV_ENGINE_PACKAGE "org.opencv.engine"
-// Class name of OpenCV engine binder object. Is needned for connection to service
-#define OPECV_ENGINE_CLASSNAME "org.opencv.engine.OpenCVEngineInterface"
+#include "EngineCommon.h"
 
 enum EngineMethonID
 {

android/service/engine/jni/include/IPackageManager.h

@@ -1,17 +1,17 @@
 #ifndef __IPACKAGE_MANAGER__
 #define __IPACKAGE_MANAGER__
 
-#include <set>
+#include <vector>
 #include <string>
 
 class IPackageManager
 {
 public:
-    virtual std::set<std::string> GetInstalledVersions() = 0;
-    virtual bool CheckVersionInstalled(const std::string& version, int platform, int cpu_id) = 0;
-    virtual bool InstallVersion(const std::string&, int platform, int cpu_id) = 0;
-    virtual std::string GetPackagePathByVersion(const std::string&, int platform, int cpu_id) = 0;
+    virtual std::vector<int> GetInstalledVersions() = 0;
+    virtual bool CheckVersionInstalled(int version, int platform, int cpu_id) = 0;
+    virtual bool InstallVersion(int version, int platform, int cpu_id) = 0;
+    virtual std::string GetPackagePathByVersion(int version, int platform, int cpu_id) = 0;
     virtual ~IPackageManager(){};
 };
 
-#endif
+#endif

android/service/engine/project.properties

@@ -11,4 +11,4 @@
 #proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt
 
 # Project target.
-target=android-8
+target=android-9

android/service/engine/res/layout/info.xml

@@ -26,7 +26,7 @@
             android:id="@+id/textView1"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
-            android:text="Version: "
+            android:text="Library version: "
             android:textAppearance="?android:attr/textAppearanceSmall" />
 
         <TextView

android/service/engine/res/layout/main.xml

@@ -30,7 +30,7 @@
             android:id="@+id/EngineVersionCaption"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
-            android:text="Version: "
+            android:text="OpenCV Manager version: "
             android:textAppearance="?android:attr/textAppearanceMedium" />
 
         <TextView

android/service/engine/src/org/opencv/engine/MarketConnector.java

@@ -20,8 +20,6 @@ public class MarketConnector
     private static final String TAG = "OpenCVEngine/MarketConnector";
     protected Context mContext;
 
-    public boolean mIncludeManager = true;
-
     public MarketConnector(Context context)
     {
         mContext = context;
@@ -100,15 +98,13 @@ public class MarketConnector
     {
         List<PackageInfo> AllPackages = mContext.getPackageManager().getInstalledPackages(PackageManager.GET_CONFIGURATIONS);
         List<PackageInfo> OpenCVPackages = new ArrayList<PackageInfo>();
-        if (mIncludeManager)
-        {
-            try {
-                OpenCVPackages.add(mContext.getPackageManager().getPackageInfo("org.opencv.engine", PackageManager.GET_CONFIGURATIONS));
-            } catch (NameNotFoundException e) {
-                Log.e(TAG, "OpenCV Manager package info was not found!");
-                e.printStackTrace();
-            }
+        try {
+            OpenCVPackages.add(mContext.getPackageManager().getPackageInfo("org.opencv.engine", PackageManager.GET_CONFIGURATIONS));
+        } catch (NameNotFoundException e) {
+            Log.e(TAG, "OpenCV Manager package info was not found!");
+            e.printStackTrace();
         }
+
         Iterator<PackageInfo> it = AllPackages.iterator();
         while(it.hasNext())
         {

android/service/engine/src/org/opencv/engine/OpenCVLibraryInfo.java

@@ -0,0 +1,40 @@
+package org.opencv.engine;
+
+public class OpenCVLibraryInfo {
+    public OpenCVLibraryInfo(String packagePath) {
+        mNativeObj = open(packagePath + "/libopencv_info.so");
+        if (mNativeObj != 0) {
+            mPackageName = getPackageName(mNativeObj);
+            mLibraryList = getLibraryList(mNativeObj);
+            mVersionName = getVersionName(mNativeObj);
+            close(mNativeObj);
+        }
+    }
+
+    public boolean status() {
+        return (mNativeObj != 0);
+    }
+
+    public String packageName() {
+        return mPackageName;
+    }
+
+    public String libraryList() {
+        return mLibraryList;
+    }
+
+    public String versionName() {
+        return mVersionName;
+    }
+
+    private long mNativeObj;
+    private String mPackageName;
+    private String mLibraryList;
+    private String mVersionName;
+
+    private native long open(String packagePath);
+    private native String getPackageName(long obj);
+    private native String getLibraryList(long obj);
+    private native String getVersionName(long obj);
+    private native void close(long obj);
+}

android/service/engine/src/org/opencv/engine/manager/ManagerActivity.java

@@ -7,7 +7,9 @@ import java.util.StringTokenizer;
 import org.opencv.engine.HardwareDetector;
 import org.opencv.engine.MarketConnector;
 import org.opencv.engine.OpenCVEngineInterface;
+import org.opencv.engine.OpenCVLibraryInfo;
 import org.opencv.engine.R;
+import android.annotation.TargetApi;
 import android.app.Activity;
 import android.app.AlertDialog;
 import android.content.BroadcastReceiver;
@@ -77,7 +79,7 @@ public class ManagerActivity extends Activity
             {
                 HardwarePlatformView.setText("Tegra");
             }
-            else if (HardwareDetector.PLATFORM_TEGRA == Platfrom)
+            else if (HardwareDetector.PLATFORM_TEGRA2 == Platfrom)
             {
                 HardwarePlatformView.setText("Tegra 2");
             }
@@ -170,9 +172,13 @@ public class ManagerActivity extends Activity
 
         mInstalledPackageView.setOnItemClickListener(new OnItemClickListener() {
 
-            public void onItemClick(AdapterView<?> arg0, View arg1, int arg2, long id) {
-                mInstalledPackageView.setTag(Integer.valueOf((int)id));
-                mActionDialog.show();
+            public void onItemClick(AdapterView<?> adapter, View view, int position, long id) {
+                //if (!mListViewItems.get((int) id).get("Name").equals("Built-in OpenCV library"));
+                if (!mInstalledPackageInfo[(int) id].packageName.equals("org.opencv.engine"))
+                {
+                    mInstalledPackageView.setTag(Integer.valueOf((int)id));
+                    mActionDialog.show();
+                }
             }
         });
 
@@ -232,8 +238,6 @@ public class ManagerActivity extends Activity
     protected class OpenCVEngineServiceConnection implements ServiceConnection
     {
         public void onServiceDisconnected(ComponentName name) {
-            // TODO Auto-generated method stub
-
         }
 
         public void onServiceConnected(ComponentName name, IBinder service) {
@@ -266,23 +270,58 @@ public class ManagerActivity extends Activity
         }
     };
 
+    @TargetApi(Build.VERSION_CODES.GINGERBREAD)
     synchronized protected void FillPackageList()
     {
         synchronized (mListViewItems) {
-            mMarket.mIncludeManager = false;
             mInstalledPackageInfo = mMarket.GetInstalledOpenCVPackages();
             mListViewItems.clear();
 
-            for (int i = 0; i < mInstalledPackageInfo.length; i++)
+            int RealPackageCount = mInstalledPackageInfo.length;
+            for (int i = 0; i < RealPackageCount; i++)
             {
+                if (mInstalledPackageInfo[i] == null)
+                    break;
+
                 // Convert to Items for package list view
                 HashMap<String,String> temp = new HashMap<String,String>();
+
+                String HardwareName = "";
+                String NativeLibDir = "";
+                String OpenCVersion = "";
+
                 String PublicName = mMarket.GetApplicationName(mInstalledPackageInfo[i].applicationInfo);
+                String PackageName = mInstalledPackageInfo[i].packageName;
+                String VersionName = mInstalledPackageInfo[i].versionName;
+
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD)
+                    NativeLibDir = mInstalledPackageInfo[i].applicationInfo.nativeLibraryDir;
+                else
+                    NativeLibDir = "/data/data/" + mInstalledPackageInfo[i].packageName + "/lib";
+
+                OpenCVLibraryInfo NativeInfo = new OpenCVLibraryInfo(NativeLibDir);
+
+                if (PackageName.equals("org.opencv.engine"))
+                {
+                    if (NativeInfo.status())
+                    {
+                        PublicName = "Built-in OpenCV library";
+                        PackageName = NativeInfo.packageName();
+                        VersionName = NativeInfo.versionName();
+                    }
+                    else
+                    {
+                        mInstalledPackageInfo[i] = mInstalledPackageInfo[RealPackageCount-1];
+                        mInstalledPackageInfo[RealPackageCount-1] = null;
+                        RealPackageCount--;
+                        i--;
+                        continue;
+                    }
+                }
 
                 int idx = 0;
-                String OpenCVersion = "unknown";
-                String HardwareName = "";
-                StringTokenizer tokenizer = new StringTokenizer(mInstalledPackageInfo[i].packageName, "_");
+                Log.d(TAG, PackageName);
+                StringTokenizer tokenizer = new StringTokenizer(PackageName, "_");
                 while (tokenizer.hasMoreTokens())
                 {
                     if (idx == 1)
@@ -303,6 +342,7 @@ public class ManagerActivity extends Activity
                 }
 
                 String ActivePackagePath;
+                String Tags = null;
                 ActivePackagePath = mActivePackageMap.get(OpenCVersion);
                 Log.d(TAG, OpenCVersion + " -> " + ActivePackagePath);
 
@@ -313,11 +353,13 @@ public class ManagerActivity extends Activity
                     if (start >= 0 && ActivePackagePath.charAt(stop) == '/')
                     {
                         temp.put("Activity", "y");
-                        PublicName += " (in use)";
+                        Tags = "active";
                     }
                     else
                     {
                         temp.put("Activity", "n");
+                        if (!PublicName.equals("Built-in OpenCV library"))
+                            Tags = "safe to remove";
                     }
                 }
                 else
@@ -325,9 +367,32 @@ public class ManagerActivity extends Activity
                     temp.put("Activity", "n");
                 }
 
+                temp.put("Version", NormalizeVersion(OpenCVersion, VersionName));
+                // HACK: OpenCV Manager for Armv7-a Neon already has Tegra3 optimizations
+                // that is enabled on proper hardware
+                if (HardwareDetector.DetectKnownPlatforms() == HardwareDetector.PLATFORM_TEGRA3 &&
+                  HardwareName.equals("armv7a neon ") &&  Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD)
+                {
+                    temp.put("Hardware", "Tegra 3");
+                    if (Tags == null)
+                    {
+                        Tags = "optimized";
+                    }
+                    else
+                    {
+                        Tags = Tags + ", optimized";
+                    }
+                }
+                else
+                {
+                    temp.put("Hardware", HardwareName);
+                }
+
+                if (Tags != null)
+                    PublicName = PublicName + " (" + Tags + ")";
+
                 temp.put("Name", PublicName);
-                temp.put("Version", NormalizeVersion(OpenCVersion, mInstalledPackageInfo[i].versionName));
-                temp.put("Hardware", HardwareName);
+
                 mListViewItems.add(temp);
             }
 
@@ -337,10 +402,16 @@ public class ManagerActivity extends Activity
 
     protected String NormalizeVersion(String OpenCVersion, String PackageVersion)
     {
+        if (OpenCVersion == null || PackageVersion == null)
+            return "unknown";
+
         int dot = PackageVersion.indexOf(".");
-        return OpenCVersion.substring(0,  OpenCVersion.length()-1) + "." +
-            OpenCVersion.toCharArray()[OpenCVersion.length()-1] + "." +
-            PackageVersion.substring(0, dot) + " rev " + PackageVersion.substring(dot+1);
+        if (dot == -1 || OpenCVersion.length() == 0)
+            return "unknown";
+        else
+            return OpenCVersion.substring(0,  OpenCVersion.length()-1) + "." +
+                OpenCVersion.toCharArray()[OpenCVersion.length()-1] + "." +
+                PackageVersion.substring(0, dot) + " rev " + PackageVersion.substring(dot+1);
     }
 
     protected String ConvertPackageName(String Name, String Version)

android/service/readme.txt

@@ -0,0 +1,33 @@
+How to select the proper version of OpenCV Manager
+--------------------------------------------------
+
+Since version 1.7 several packages of OpenCV Manager are built. Every package is targeted for some
+specific hardware platform and includes corresponding OpenCV binaries. So, in most cases OpenCV
+Manager uses built-in version of OpenCV. Separate package with OpenCV binaries is currently used in
+a single rare case, when an ARMv7-A processor without NEON support is detected. In this case an
+additional binary package is used. The new package selection logic in most cases simplifies OpenCV
+installation on end user devices. In most cases OpenCV Manager may be installed automatically from
+Google Play.
+
+If Google Play is not available (i.e. on emulator, developer board, etc), you can install it
+manually using adb tool:
+
+.. code-block:: sh
+
+    adb install OpenCV-2.4.3-android-sdk/apk/OpenCV_2.4.3.2_Manager_2.4_<platform>.apk
+
+Use the table below to determine proper OpenCV Manager package for your device:
+
++------------------------------+--------------+-----------------------------------------------------+
+| Hardware Platform            | Android ver. | Package name                                        |
++==============================+==============+=====================================================+
+| armeabi-v7a (ARMv7-A + NEON) |    >= 2.3    | OpenCV_2.4.3.2_Manager_2.4_armv7a-neon.apk          |
++------------------------------+--------------+-----------------------------------------------------+
+| armeabi-v7a (ARMv7-A + NEON) |     = 2.2    | OpenCV_2.4.3.2_Manager_2.4_armv7a-neon-android8.apk |
++------------------------------+--------------+-----------------------------------------------------+
+| armeabi (ARMv5, ARMv6)       |    >= 2.3    | OpenCV_2.4.3.2_Manager_2.4_armeabi.apk              |
++------------------------------+--------------+-----------------------------------------------------+
+| Intel x86                    |    >= 2.3    | OpenCV_2.4.3.2_Manager_2.4_x86.apk                  |
++------------------------------+--------------+-----------------------------------------------------+
+| MIPS                         |    >= 2.3    | OpenCV_2.4.3.2_Manager_2.4_mips.apk                 |
++------------------------------+--------------+-----------------------------------------------------+

apps/haartraining/CMakeLists.txt

@@ -1,7 +1,3 @@
-if(IOS OR ANDROID)
-  return()
-endif()
-
 SET(OPENCV_HAARTRAINING_DEPS opencv_core opencv_imgproc opencv_highgui opencv_objdetect opencv_calib3d opencv_video opencv_features2d opencv_flann opencv_legacy)
 ocv_check_dependencies(${OPENCV_HAARTRAINING_DEPS})
 

apps/traincascade/CMakeLists.txt

@@ -1,7 +1,3 @@
-if(IOS OR ANDROID)
-  return()
-endif()
-
 SET(OPENCV_TRAINCASCADE_DEPS opencv_core opencv_ml opencv_imgproc opencv_objdetect opencv_highgui opencv_calib3d opencv_video opencv_features2d opencv_flann opencv_legacy)
 ocv_check_dependencies(${OPENCV_TRAINCASCADE_DEPS})
 

apps/traincascade/boost.cpp

@@ -360,7 +360,7 @@ CvDTreeNode* CvCascadeBoostTrainData::subsample_data( const CvMat* _subsample_id
 
             if (is_buf_16u)
             {
-                unsigned short* udst_idx = (unsigned short*)(buf->data.s + root->buf_idx*buf->cols +
+                unsigned short* udst_idx = (unsigned short*)(buf->data.s + root->buf_idx*get_length_subbuf() +
                     vi*sample_count + data_root->offset);
                 for( int i = 0; i < num_valid; i++ )
                 {
@@ -373,7 +373,7 @@ CvDTreeNode* CvCascadeBoostTrainData::subsample_data( const CvMat* _subsample_id
             }
             else
             {
-                int* idst_idx = buf->data.i + root->buf_idx*buf->cols +
+                int* idst_idx = buf->data.i + root->buf_idx*get_length_subbuf() +
                     vi*sample_count + root->offset;
                 for( int i = 0; i < num_valid; i++ )
                 {
@@ -390,14 +390,14 @@ CvDTreeNode* CvCascadeBoostTrainData::subsample_data( const CvMat* _subsample_id
         const int* src_lbls = get_cv_labels(data_root, (int*)(uchar*)inn_buf);
         if (is_buf_16u)
         {
-            unsigned short* udst = (unsigned short*)(buf->data.s + root->buf_idx*buf->cols +
+            unsigned short* udst = (unsigned short*)(buf->data.s + root->buf_idx*get_length_subbuf() +
                 (workVarCount-1)*sample_count + root->offset);
             for( int i = 0; i < count; i++ )
                 udst[i] = (unsigned short)src_lbls[sidx[i]];
         }
         else
         {
-            int* idst = buf->data.i + root->buf_idx*buf->cols +
+            int* idst = buf->data.i + root->buf_idx*get_length_subbuf() +
                 (workVarCount-1)*sample_count + root->offset;
             for( int i = 0; i < count; i++ )
                 idst[i] = src_lbls[sidx[i]];
@@ -407,14 +407,14 @@ CvDTreeNode* CvCascadeBoostTrainData::subsample_data( const CvMat* _subsample_id
         const int* sample_idx_src = get_sample_indices(data_root, (int*)(uchar*)inn_buf);
         if (is_buf_16u)
         {
-            unsigned short* sample_idx_dst = (unsigned short*)(buf->data.s + root->buf_idx*buf->cols +
+            unsigned short* sample_idx_dst = (unsigned short*)(buf->data.s + root->buf_idx*get_length_subbuf() +
                 workVarCount*sample_count + root->offset);
             for( int i = 0; i < count; i++ )
                 sample_idx_dst[i] = (unsigned short)sample_idx_src[sidx[i]];
         }
         else
         {
-            int* sample_idx_dst = buf->data.i + root->buf_idx*buf->cols +
+            int* sample_idx_dst = buf->data.i + root->buf_idx*get_length_subbuf() +
                 workVarCount*sample_count + root->offset;
             for( int i = 0; i < count; i++ )
                 sample_idx_dst[i] = sample_idx_src[sidx[i]];
@@ -489,6 +489,10 @@ void CvCascadeBoostTrainData::setData( const CvFeatureEvaluator* _featureEvaluat
     int* idst = 0;
     unsigned short* udst = 0;
 
+    uint64 effective_buf_size = 0;
+    int effective_buf_height = 0, effective_buf_width = 0;
+
+
     clear();
     shared = true;
     have_labels = true;
@@ -548,13 +552,28 @@ void CvCascadeBoostTrainData::setData( const CvFeatureEvaluator* _featureEvaluat
     var_type->data.i[var_count] = cat_var_count;
     var_type->data.i[var_count+1] = cat_var_count+1;
     work_var_count = ( cat_var_count ? 0 : numPrecalcIdx ) + 1/*cv_lables*/;
-    buf_size = (work_var_count + 1) * sample_count/*sample_indices*/;
     buf_count = 2;
 
-    if ( is_buf_16u )
-        buf = cvCreateMat( buf_count, buf_size, CV_16UC1 );
+    buf_size = -1; // the member buf_size is obsolete
+
+    effective_buf_size = (uint64)(work_var_count + 1)*(uint64)sample_count * buf_count; // this is the total size of "CvMat buf" to be allocated
+    effective_buf_width = sample_count;
+    effective_buf_height = work_var_count+1;
+
+    if (effective_buf_width >= effective_buf_height)
+        effective_buf_height *= buf_count;
     else
-        buf = cvCreateMat( buf_count, buf_size, CV_32SC1 );
+        effective_buf_width *= buf_count;
+
+    if ((uint64)effective_buf_width * (uint64)effective_buf_height != effective_buf_size)
+    {
+        CV_Error(CV_StsBadArg, "The memory buffer cannot be allocated since its size exceeds integer fields limit");
+    }
+
+    if ( is_buf_16u )
+        buf = cvCreateMat( effective_buf_height, effective_buf_width, CV_16UC1 );
+    else
+        buf = cvCreateMat( effective_buf_height, effective_buf_width, CV_32SC1 );
 
     cat_count = cvCreateMat( 1, cat_var_count + 1, CV_32SC1 );
 
@@ -609,7 +628,7 @@ void CvCascadeBoostTrainData::setData( const CvFeatureEvaluator* _featureEvaluat
     priors_mult = cvCloneMat( priors );
     counts = cvCreateMat( 1, get_num_classes(), CV_32SC1 );
     direction = cvCreateMat( 1, sample_count, CV_8UC1 );
-    split_buf = cvCreateMat( 1, sample_count, CV_32SC1 );
+    split_buf = cvCreateMat( 1, sample_count, CV_32SC1 );//TODO: make a pointer
 }
 
 void CvCascadeBoostTrainData::free_train_data()
@@ -652,10 +671,10 @@ void CvCascadeBoostTrainData::get_ord_var_data( CvDTreeNode* n, int vi, float* o
     if ( vi < numPrecalcIdx )
     {
         if( !is_buf_16u )
-            *sortedIndices = buf->data.i + n->buf_idx*buf->cols + vi*sample_count + n->offset;
+            *sortedIndices = buf->data.i + n->buf_idx*get_length_subbuf() + vi*sample_count + n->offset;
         else
         {
-            const unsigned short* shortIndices = (const unsigned short*)(buf->data.s + n->buf_idx*buf->cols +
+            const unsigned short* shortIndices = (const unsigned short*)(buf->data.s + n->buf_idx*get_length_subbuf() +
                                                     vi*sample_count + n->offset );
             for( int i = 0; i < nodeSampleCount; i++ )
                 sortedIndicesBuf[i] = shortIndices[i];
@@ -1027,6 +1046,7 @@ void CvCascadeBoostTree::split_node_data( CvDTreeNode* node )
     int newBufIdx = data->get_child_buf_idx( node );
     int workVarCount = data->get_work_var_count();
     CvMat* buf = data->buf;
+    size_t length_buf_row = data->get_length_subbuf();
     cv::AutoBuffer<uchar> inn_buf(n*(3*sizeof(int)+sizeof(float)));
     int* tempBuf = (int*)(uchar*)inn_buf;
     bool splitInputData;
@@ -1070,7 +1090,7 @@ void CvCascadeBoostTree::split_node_data( CvDTreeNode* node )
         if (data->is_buf_16u)
         {
             ushort *ldst, *rdst;
-            ldst = (ushort*)(buf->data.s + left->buf_idx*buf->cols +
+            ldst = (ushort*)(buf->data.s + left->buf_idx*length_buf_row +
                 vi*scount + left->offset);
             rdst = (ushort*)(ldst + nl);
 
@@ -1096,9 +1116,9 @@ void CvCascadeBoostTree::split_node_data( CvDTreeNode* node )
         else
         {
             int *ldst, *rdst;
-            ldst = buf->data.i + left->buf_idx*buf->cols +
+            ldst = buf->data.i + left->buf_idx*length_buf_row +
                 vi*scount + left->offset;
-            rdst = buf->data.i + right->buf_idx*buf->cols +
+            rdst = buf->data.i + right->buf_idx*length_buf_row +
                 vi*scount + right->offset;
 
             // split sorted
@@ -1131,9 +1151,9 @@ void CvCascadeBoostTree::split_node_data( CvDTreeNode* node )
 
     if (data->is_buf_16u)
     {
-        unsigned short *ldst = (unsigned short *)(buf->data.s + left->buf_idx*buf->cols +
+        unsigned short *ldst = (unsigned short *)(buf->data.s + left->buf_idx*length_buf_row +
             (workVarCount-1)*scount + left->offset);
-        unsigned short *rdst = (unsigned short *)(buf->data.s + right->buf_idx*buf->cols +
+        unsigned short *rdst = (unsigned short *)(buf->data.s + right->buf_idx*length_buf_row +
             (workVarCount-1)*scount + right->offset);
 
         for( int i = 0; i < n; i++ )
@@ -1154,9 +1174,9 @@ void CvCascadeBoostTree::split_node_data( CvDTreeNode* node )
     }
     else
     {
-        int *ldst = buf->data.i + left->buf_idx*buf->cols +
+        int *ldst = buf->data.i + left->buf_idx*length_buf_row +
             (workVarCount-1)*scount + left->offset;
-        int *rdst = buf->data.i + right->buf_idx*buf->cols +
+        int *rdst = buf->data.i + right->buf_idx*length_buf_row +
             (workVarCount-1)*scount + right->offset;
 
         for( int i = 0; i < n; i++ )
@@ -1184,9 +1204,9 @@ void CvCascadeBoostTree::split_node_data( CvDTreeNode* node )
 
     if (data->is_buf_16u)
     {
-        unsigned short* ldst = (unsigned short*)(buf->data.s + left->buf_idx*buf->cols +
+        unsigned short* ldst = (unsigned short*)(buf->data.s + left->buf_idx*length_buf_row +
             workVarCount*scount + left->offset);
-        unsigned short* rdst = (unsigned short*)(buf->data.s + right->buf_idx*buf->cols +
+        unsigned short* rdst = (unsigned short*)(buf->data.s + right->buf_idx*length_buf_row +
             workVarCount*scount + right->offset);
         for (int i = 0; i < n; i++)
         {
@@ -1205,9 +1225,9 @@ void CvCascadeBoostTree::split_node_data( CvDTreeNode* node )
     }
     else
     {
-        int* ldst = buf->data.i + left->buf_idx*buf->cols +
+        int* ldst = buf->data.i + left->buf_idx*length_buf_row +
             workVarCount*scount + left->offset;
-        int* rdst = buf->data.i + right->buf_idx*buf->cols +
+        int* rdst = buf->data.i + right->buf_idx*length_buf_row +
             workVarCount*scount + right->offset;
         for (int i = 0; i < n; i++)
         {
@@ -1352,6 +1372,7 @@ void CvCascadeBoost::update_weights( CvBoostTree* tree )
         sampleIdx = data->get_sample_indices( data->data_root, sampleIdxBuf );
     }
     CvMat* buf = data->buf;
+    size_t length_buf_row = data->get_length_subbuf();
     if( !tree ) // before training the first tree, initialize weights and other parameters
     {
         int* classLabelsBuf = (int*)cur_inn_buf_pos; cur_inn_buf_pos = (uchar*)(classLabelsBuf + n);
@@ -1375,7 +1396,7 @@ void CvCascadeBoost::update_weights( CvBoostTree* tree )
 
         if (data->is_buf_16u)
         {
-            unsigned short* labels = (unsigned short*)(buf->data.s + data->data_root->buf_idx*buf->cols +
+            unsigned short* labels = (unsigned short*)(buf->data.s + data->data_root->buf_idx*length_buf_row +
                 data->data_root->offset + (data->work_var_count-1)*data->sample_count);
             for( int i = 0; i < n; i++ )
             {
@@ -1393,7 +1414,7 @@ void CvCascadeBoost::update_weights( CvBoostTree* tree )
         }
         else
         {
-            int* labels = buf->data.i + data->data_root->buf_idx*buf->cols +
+            int* labels = buf->data.i + data->data_root->buf_idx*length_buf_row +
                 data->data_root->offset + (data->work_var_count-1)*data->sample_count;
 
             for( int i = 0; i < n; i++ )

cmake/OpenCVDetectAndroidSDK.cmake

@@ -179,7 +179,7 @@ unset(__android_project_chain CACHE)
 #add_android_project(target_name ${path} NATIVE_DEPS opencv_core LIBRARY_DEPS ${OpenCV_BINARY_DIR} SDK_TARGET 11)
 macro(add_android_project target path)
   # parse arguments
-  set(android_proj_arglist NATIVE_DEPS LIBRARY_DEPS SDK_TARGET IGNORE_JAVA)
+  set(android_proj_arglist NATIVE_DEPS LIBRARY_DEPS SDK_TARGET IGNORE_JAVA IGNORE_MANIFEST)
   set(__varname "android_proj_")
   foreach(v ${android_proj_arglist})
     set(${__varname}${v} "")
@@ -220,9 +220,13 @@ macro(add_android_project target path)
     # get project sources
     file(GLOB_RECURSE android_proj_files RELATIVE "${path}" "${path}/res/*" "${path}/src/*")
 
+    if(NOT android_proj_IGNORE_MANIFEST)
+      list(APPEND android_proj_files ${ANDROID_MANIFEST_FILE})
+    endif()
+
     # copy sources out from the build tree
     set(android_proj_file_deps "")
-    foreach(f ${android_proj_files} ${ANDROID_MANIFEST_FILE})
+    foreach(f ${android_proj_files})
       add_custom_command(
         OUTPUT "${android_proj_bin_dir}/${f}"
         COMMAND ${CMAKE_COMMAND} -E copy "${path}/${f}" "${android_proj_bin_dir}/${f}"
@@ -298,7 +302,7 @@ macro(add_android_project target path)
          COMMAND ${CMAKE_COMMAND} -E touch "${android_proj_bin_dir}/bin/${target}-debug.apk" # needed because ant does not update the timestamp of updated apk
          WORKING_DIRECTORY "${android_proj_bin_dir}"
          MAIN_DEPENDENCY "${android_proj_bin_dir}/${ANDROID_MANIFEST_FILE}"
-         DEPENDS "${OpenCV_BINARY_DIR}/bin/.classes.jar.dephelper" opencv_java # as we are part of OpenCV we can just force this dependency
+         DEPENDS "${OpenCV_BINARY_DIR}/bin/classes.jar.dephelper" opencv_java # as we are part of OpenCV we can just force this dependency
          DEPENDS ${android_proj_file_deps} ${JNI_LIB_NAME})
     endif()
 
@@ -324,6 +328,7 @@ macro(add_android_project target path)
       install(FILES "${OpenCV_BINARY_DIR}/bin/${target}.apk" DESTINATION "samples" COMPONENT main)
       get_filename_component(sample_dir "${path}" NAME)
       #java part
+      list(REMOVE_ITEM android_proj_files ${ANDROID_MANIFEST_FILE})
       foreach(f ${android_proj_files} ${ANDROID_MANIFEST_FILE})
         get_filename_component(install_subdir "${f}" PATH)
         install(FILES "${android_proj_bin_dir}/${f}" DESTINATION "samples/${sample_dir}/${install_subdir}" COMPONENT main)

cmake/OpenCVDetectCUDA.cmake

@@ -3,12 +3,17 @@ if(${CMAKE_VERSION} VERSION_LESS "2.8.3")
   return()
 endif()
 
-if (NOT MSVC AND NOT CMAKE_COMPILER_IS_GNUCXX OR MINGW)
-  message(STATUS "CUDA compilation was disabled (due to unsuppoted host compiler).")
+if(WIN32 AND NOT MSVC)
+  message(STATUS "CUDA compilation is disabled (due to only Visual Studio compiler supported on your platform).")
   return()
 endif()
 
-find_package(CUDA 4.1)
+if(CMAKE_COMPILER_IS_GNUCXX AND NOT APPLE AND CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+  message(STATUS "CUDA compilation is disabled (due to Clang unsupported on your platform).")
+  return()
+endif()
+
+find_package(CUDA 4.2 QUIET)
 
 if(CUDA_FOUND)
   set(HAVE_CUDA 1)
@@ -21,15 +26,20 @@ if(CUDA_FOUND)
     set(HAVE_CUBLAS 1)
   endif()
 
-  message(STATUS "CUDA detected: " ${CUDA_VERSION})
-
-  if(${CUDA_VERSION_STRING} VERSION_GREATER "4.1")
-    set(CUDA_ARCH_BIN "1.1 1.2 1.3 2.0 2.1(2.0) 3.0" CACHE STRING "Specify 'real' GPU architectures to build binaries for, BIN(PTX) format is supported")
-  else()
-    set(CUDA_ARCH_BIN "1.1 1.2 1.3 2.0 2.1(2.0)" CACHE STRING "Specify 'real' GPU architectures to build binaries for, BIN(PTX) format is supported")
+  if(WITH_NVCUVID)
+    find_cuda_helper_libs(nvcuvid)
+    set(HAVE_NVCUVID 1)
   endif()
 
-  set(CUDA_ARCH_PTX "2.0" CACHE STRING "Specify 'virtual' PTX architectures to build PTX intermediate code for")
+  message(STATUS "CUDA detected: " ${CUDA_VERSION})
+
+  if (CARMA)
+    set(CUDA_ARCH_BIN "2.1(2.0) 3.0" CACHE STRING "Specify 'real' GPU architectures to build binaries for, BIN(PTX) format is supported")
+    set(CUDA_ARCH_PTX "3.0" CACHE STRING "Specify 'virtual' PTX architectures to build PTX intermediate code for")
+  else()
+    set(CUDA_ARCH_BIN "1.1 1.2 1.3 2.0 2.1(2.0) 3.0" CACHE STRING "Specify 'real' GPU architectures to build binaries for, BIN(PTX) format is supported")
+    set(CUDA_ARCH_PTX "2.0 3.0" CACHE STRING "Specify 'virtual' PTX architectures to build PTX intermediate code for")
+  endif()
 
   string(REGEX REPLACE "\\." "" ARCH_BIN_NO_POINTS "${CUDA_ARCH_BIN}")
   string(REGEX REPLACE "\\." "" ARCH_PTX_NO_POINTS "${CUDA_ARCH_PTX}")
@@ -67,11 +77,20 @@ if(CUDA_FOUND)
 
   # Tell NVCC to add PTX intermediate code for the specified architectures
   string(REGEX MATCHALL "[0-9]+" ARCH_LIST "${ARCH_PTX_NO_POINTS}")
-    foreach(ARCH IN LISTS ARCH_LIST)
-      set(NVCC_FLAGS_EXTRA ${NVCC_FLAGS_EXTRA} -gencode arch=compute_${ARCH},code=compute_${ARCH})
-      set(OPENCV_CUDA_ARCH_PTX "${OPENCV_CUDA_ARCH_PTX} ${ARCH}")
-      set(OPENCV_CUDA_ARCH_FEATURES "${OPENCV_CUDA_ARCH_FEATURES} ${ARCH}")
-    endforeach()
+  foreach(ARCH IN LISTS ARCH_LIST)
+    set(NVCC_FLAGS_EXTRA ${NVCC_FLAGS_EXTRA} -gencode arch=compute_${ARCH},code=compute_${ARCH})
+    set(OPENCV_CUDA_ARCH_PTX "${OPENCV_CUDA_ARCH_PTX} ${ARCH}")
+    set(OPENCV_CUDA_ARCH_FEATURES "${OPENCV_CUDA_ARCH_FEATURES} ${ARCH}")
+  endforeach()
+
+  if(CARMA)
+    set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} --target-cpu-architecture=ARM" )
+
+    if (CMAKE_VERSION VERSION_LESS 2.8.10)
+      set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -ccbin=${CMAKE_CXX_COMPILER}" )
+    endif()
+
+  endif()
 
   # These vars will be processed in other scripts
   set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} ${NVCC_FLAGS_EXTRA})
@@ -79,7 +98,7 @@ if(CUDA_FOUND)
 
   message(STATUS "CUDA NVCC target flags: ${CUDA_NVCC_FLAGS}")
 
-  OCV_OPTION(CUDA_FAST_MATH  "Enable --use_fast_math for CUDA compiler " OFF)
+  OCV_OPTION(CUDA_FAST_MATH "Enable --use_fast_math for CUDA compiler " OFF)
 
   if(CUDA_FAST_MATH)
     set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --use_fast_math)
@@ -87,7 +106,6 @@ if(CUDA_FOUND)
 
   mark_as_advanced(CUDA_BUILD_CUBIN CUDA_BUILD_EMULATION CUDA_VERBOSE_BUILD CUDA_SDK_ROOT_DIR)
 
-  unset(CUDA_npp_LIBRARY CACHE)
   find_cuda_helper_libs(npp)
 
   macro(ocv_cuda_compile VAR)
@@ -101,15 +119,15 @@ if(CUDA_FOUND)
       string(REPLACE "-ggdb3" "" ${var} "${${var}}")
     endforeach()
 
-    if (BUILD_SHARED_LIBS)
+    if(BUILD_SHARED_LIBS)
       set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} -Xcompiler -DCVAPI_EXPORTS)
     endif()
 
     if(UNIX OR APPLE)
-      set (CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} -Xcompiler -fPIC)
+      set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} -Xcompiler -fPIC)
     endif()
     if(APPLE)
-      set (CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} -Xcompiler -fno-finite-math-only)
+      set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} -Xcompiler -fno-finite-math-only)
     endif()
 
     # disabled because of multiple warnings during building nvcc auto generated files

cmake/OpenCVDetectCXXCompiler.cmake

@@ -54,7 +54,7 @@ endif()
 # Detect GNU version:
 # ----------------------------------------------------------------------------
 if(CMAKE_COMPILER_IS_GNUCXX)
-    execute_process(COMMAND ${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1} --version
+    execute_process(COMMAND ${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1} -dumpversion
                   OUTPUT_VARIABLE CMAKE_OPENCV_GCC_VERSION_FULL
                   OUTPUT_STRIP_TRAILING_WHITESPACE)
 

cmake/OpenCVDetectOpenCL.cmake

@@ -1,78 +1,146 @@
 if(APPLE)
-    set(OPENCL_FOUND YES)
-    set(OPENCL_LIBRARIES "-framework OpenCL")
+  set(OPENCL_FOUND YES)
+  set(OPENCL_LIBRARIES "-framework OpenCL")
 else()
-    #find_package(OpenCL QUIET)
-    if(WITH_OPENCLAMDFFT)
-            find_path(CLAMDFFT_INCLUDE_DIR
-                NAMES clAmdFft.h)
-            find_library(CLAMDFFT_LIBRARIES
-                NAMES clAmdFft.Runtime)
+  find_package(OpenCL QUIET)
+  if(WITH_OPENCLAMDFFT)
+    set(CLAMDFFT_SEARCH_PATH $ENV{CLAMDFFT_PATH})
+    if(NOT CLAMDFFT_SEARCH_PATH)
+      if(WIN32)
+        set( CLAMDFFT_SEARCH_PATH "C:\\Program Files (x86)\\AMD\\clAmdFft" )
+      endif()
     endif()
-    if(WITH_OPENCLAMDBLAS)
-            find_path(CLAMDBLAS_INCLUDE_DIR
-                NAMES clAmdBlas.h)
-            find_library(CLAMDBLAS_LIBRARIES
-                NAMES clAmdBlas)
-    endif()
-    # Try AMD/ATI Stream SDK
-    if (NOT OPENCL_FOUND)
-        set(ENV_AMDSTREAMSDKROOT $ENV{AMDAPPSDKROOT})
-        set(ENV_OPENCLROOT $ENV{OPENCLROOT})
-        set(ENV_CUDA_PATH $ENV{CUDA_PATH})
-        if(ENV_AMDSTREAMSDKROOT)
-            set(OPENCL_INCLUDE_SEARCH_PATH ${ENV_AMDSTREAMSDKROOT}/include)
-            if(CMAKE_SIZEOF_VOID_P EQUAL 4)
-                set(OPENCL_LIB_SEARCH_PATH ${OPENCL_LIB_SEARCH_PATH} ${ENV_AMDSTREAMSDKROOT}/lib/x86)
-            else()
-                set(OPENCL_LIB_SEARCH_PATH ${OPENCL_LIB_SEARCH_PATH} ${ENV_AMDSTREAMSDKROOT}/lib/x86_64)
-            endif()
-        elseif(ENV_CUDAPATH AND WIN32)
-            set(OPENCL_INCLUDE_SEARCH_PATH ${ENV_CUDA_PATH}/include)
-            if(CMAKE_SIZEOF_VOID_P EQUAL 4)
-                set(OPENCL_LIB_SEARCH_PATH ${OPENCL_LIB_SEARCH_PATH} ${ENV_CUDA_PATH}/lib/Win32)
-            else()
-                set(OPENCL_LIB_SEARCH_PATH ${OPENCL_LIB_SEARCH_PATH} ${ENV_CUDA_PATH}/lib/x64)
-            endif()
-        elseif(ENV_OPENCLROOT AND UNIX)
-            set(OPENCL_INCLUDE_SEARCH_PATH ${ENV_OPENCLROOT}/inc)
-            if(CMAKE_SIZEOF_VOID_P EQUAL 4)
-                set(OPENCL_LIB_SEARCH_PATH ${OPENCL_LIB_SEARCH_PATH} /usr/lib)
-            else()
-                set(OPENCL_LIB_SEARCH_PATH ${OPENCL_LIB_SEARCH_PATH} /usr/lib64)
-            endif()
-        endif()
-
-        if(OPENCL_INCLUDE_SEARCH_PATH)
-            find_path(OPENCL_INCLUDE_DIR
-                NAMES CL/cl.h OpenCL/cl.h
-                PATHS ${OPENCL_INCLUDE_SEARCH_PATH}
-                NO_DEFAULT_PATH)
-        else()
-            find_path(OPENCL_INCLUDE_DIR
-                NAMES CL/cl.h OpenCL/cl.h)
-        endif()
-
-        if(OPENCL_LIB_SEARCH_PATH)
-            find_library(OPENCL_LIBRARY NAMES OpenCL PATHS ${OPENCL_LIB_SEARCH_PATH} NO_DEFAULT_PATH)
-        else()
-            find_library(OPENCL_LIBRARY NAMES OpenCL)
-        endif()
-
-        include(FindPackageHandleStandardArgs)
-        find_package_handle_standard_args(
-          OPENCL
-          DEFAULT_MSG
-          OPENCL_LIBRARY OPENCL_INCLUDE_DIR
-          )
-
-        if(OPENCL_FOUND)
-            set(OPENCL_LIBRARIES ${OPENCL_LIBRARY})
-            set(HAVE_OPENCL 1)
-        else()
-            set(OPENCL_LIBRARIES)
-        endif()
+    set( CLAMDFFT_INCLUDE_SEARCH_PATH ${CLAMDFFT_SEARCH_PATH}/include )
+    if(UNIX)
+      if(CMAKE_SIZEOF_VOID_P EQUAL 4)
+        set(CLAMDFFT_LIB_SEARCH_PATH /usr/lib)
+      else()
+        set(CLAMDFFT_LIB_SEARCH_PATH /usr/lib64)
+      endif()
     else()
-        set(HAVE_OPENCL 1)
+      if(CMAKE_SIZEOF_VOID_P EQUAL 4)
+        set(CLAMDFFT_LIB_SEARCH_PATH ${CLAMDFFT_SEARCH_PATH}\\lib32\\import)
+      else()
+        set(CLAMDFFT_LIB_SEARCH_PATH ${CLAMDFFT_SEARCH_PATH}\\lib64\\import)
+      endif()
     endif()
+    find_path(CLAMDFFT_INCLUDE_DIR
+      NAMES clAmdFft.h
+      PATHS ${CLAMDFFT_INCLUDE_SEARCH_PATH}
+      PATH_SUFFIXES clAmdFft
+      NO_DEFAULT_PATH)
+    find_library(CLAMDFFT_LIBRARY
+      NAMES clAmdFft.Runtime
+      PATHS ${CLAMDFFT_LIB_SEARCH_PATH}
+      NO_DEFAULT_PATH)
+    if(CLAMDFFT_LIBRARY)
+      set(CLAMDFFT_LIBRARIES ${CLAMDFFT_LIBRARY})
+    else()
+      set(CLAMDFFT_LIBRARIES "")
+    endif()
+  endif()
+  if(WITH_OPENCLAMDBLAS)
+    set(CLAMDBLAS_SEARCH_PATH $ENV{CLAMDBLAS_PATH})
+    if(NOT CLAMDBLAS_SEARCH_PATH)
+      if(WIN32)
+        set( CLAMDBLAS_SEARCH_PATH "C:\\Program Files (x86)\\AMD\\clAmdBlas" )
+      endif()
+    endif()
+    set( CLAMDBLAS_INCLUDE_SEARCH_PATH ${CLAMDBLAS_SEARCH_PATH}/include )
+    if(UNIX)
+      if(CMAKE_SIZEOF_VOID_P EQUAL 4)
+        set(CLAMDBLAS_LIB_SEARCH_PATH /usr/lib)
+      else()
+        set(CLAMDBLAS_LIB_SEARCH_PATH /usr/lib64)
+      endif()
+    else()
+      if(CMAKE_SIZEOF_VOID_P EQUAL 4)
+        set(CLAMDBLAS_LIB_SEARCH_PATH ${CLAMDBLAS_SEARCH_PATH}\\lib32\\import)
+      else()
+        set(CLAMDBLAS_LIB_SEARCH_PATH ${CLAMDBLAS_SEARCH_PATH}\\lib64\\import)
+      endif()
+    endif()
+    find_path(CLAMDBLAS_INCLUDE_DIR
+      NAMES clAmdBlas.h
+      PATHS ${CLAMDBLAS_INCLUDE_SEARCH_PATH}
+      PATH_SUFFIXES clAmdBlas
+      NO_DEFAULT_PATH)
+    find_library(CLAMDBLAS_LIBRARY
+      NAMES clAmdBlas
+      PATHS ${CLAMDBLAS_LIB_SEARCH_PATH}
+      NO_DEFAULT_PATH)
+    if(CLAMDBLAS_LIBRARY)
+      set(CLAMDBLAS_LIBRARIES ${CLAMDBLAS_LIBRARY})
+    else()
+      set(CLAMDBLAS_LIBRARIES "")
+    endif()
+  endif()
+  # Try AMD/ATI Stream SDK
+  if (NOT OPENCL_FOUND)
+    set(ENV_AMDSTREAMSDKROOT $ENV{AMDAPPSDKROOT})
+    set(ENV_AMDAPPSDKROOT $ENV{AMDAPPSDKROOT})
+    set(ENV_OPENCLROOT $ENV{OPENCLROOT})
+    set(ENV_CUDA_PATH $ENV{CUDA_PATH})
+    if(ENV_AMDSTREAMSDKROOT)
+      set(OPENCL_INCLUDE_SEARCH_PATH ${ENV_AMDAPPSDKROOT}/include)
+      if(CMAKE_SIZEOF_VOID_P EQUAL 4)
+        set(OPENCL_LIB_SEARCH_PATH ${OPENCL_LIB_SEARCH_PATH} ${ENV_AMDAPPSDKROOT}/lib/x86)
+      else()
+        set(OPENCL_LIB_SEARCH_PATH ${OPENCL_LIB_SEARCH_PATH} ${ENV_AMDAPPSDKROOT}/lib/x86_64)
+      endif()
+    elseif(ENV_AMDSTREAMSDKROOT)
+      set(OPENCL_INCLUDE_SEARCH_PATH ${ENV_AMDSTREAMSDKROOT}/include)
+      if(CMAKE_SIZEOF_VOID_P EQUAL 4)
+        set(OPENCL_LIB_SEARCH_PATH ${OPENCL_LIB_SEARCH_PATH} ${ENV_AMDSTREAMSDKROOT}/lib/x86)
+      else()
+        set(OPENCL_LIB_SEARCH_PATH ${OPENCL_LIB_SEARCH_PATH} ${ENV_AMDSTREAMSDKROOT}/lib/x86_64)
+      endif()
+    elseif(ENV_CUDA_PATH AND WIN32)
+      set(OPENCL_INCLUDE_SEARCH_PATH ${ENV_CUDA_PATH}/include)
+      if(CMAKE_SIZEOF_VOID_P EQUAL 4)
+        set(OPENCL_LIB_SEARCH_PATH ${OPENCL_LIB_SEARCH_PATH} ${ENV_CUDA_PATH}/lib/Win32)
+      else()
+        set(OPENCL_LIB_SEARCH_PATH ${OPENCL_LIB_SEARCH_PATH} ${ENV_CUDA_PATH}/lib/x64)
+      endif()
+    elseif(ENV_OPENCLROOT AND UNIX)
+      set(OPENCL_INCLUDE_SEARCH_PATH ${ENV_OPENCLROOT}/inc)
+      if(CMAKE_SIZEOF_VOID_P EQUAL 4)
+        set(OPENCL_LIB_SEARCH_PATH ${OPENCL_LIB_SEARCH_PATH} /usr/lib)
+      else()
+        set(OPENCL_LIB_SEARCH_PATH ${OPENCL_LIB_SEARCH_PATH} /usr/lib64)
+      endif()
+    endif()
+
+    if(OPENCL_INCLUDE_SEARCH_PATH)
+      find_path(OPENCL_INCLUDE_DIR
+        NAMES CL/cl.h OpenCL/cl.h
+        PATHS ${OPENCL_INCLUDE_SEARCH_PATH}
+        NO_DEFAULT_PATH)
+    else()
+      find_path(OPENCL_INCLUDE_DIR
+        NAMES CL/cl.h OpenCL/cl.h)
+    endif()
+
+    if(OPENCL_LIB_SEARCH_PATH)
+      find_library(OPENCL_LIBRARY NAMES OpenCL PATHS ${OPENCL_LIB_SEARCH_PATH} NO_DEFAULT_PATH)
+    else()
+      find_library(OPENCL_LIBRARY NAMES OpenCL)
+    endif()
+
+    include(FindPackageHandleStandardArgs)
+    find_package_handle_standard_args(
+      OPENCL
+      DEFAULT_MSG
+      OPENCL_LIBRARY OPENCL_INCLUDE_DIR
+      )
+
+    if(OPENCL_FOUND)
+      set(OPENCL_LIBRARIES ${OPENCL_LIBRARY})
+      set(HAVE_OPENCL 1)
+    else()
+      set(OPENCL_LIBRARIES)
+    endif()
+  else()
+    set(HAVE_OPENCL 1)
+  endif()
 endif()

cmake/OpenCVDetectTBB.cmake

@@ -1,4 +1,4 @@
-if(ANDROID AND NOT MIPS)
+if(BUILD_TBB)
   add_subdirectory("${OpenCV_SOURCE_DIR}/3rdparty/tbb")
   include_directories(SYSTEM ${TBB_INCLUDE_DIRS})
   set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} tbb)
@@ -22,7 +22,7 @@ endif()
 
 if(NOT HAVE_TBB)
   set(TBB_DEFAULT_INCLUDE_DIRS
-    "/opt/intel/tbb" "/usr/local/include" "/usr/include"
+    "/opt/intel/tbb/include" "/usr/local/include" "/usr/include"
     "C:/Program Files/Intel/TBB" "C:/Program Files (x86)/Intel/TBB"
     "C:/Program Files (x86)/tbb/include"
     "C:/Program Files (x86)/tbb/include"

cmake/OpenCVExtraTargets.cmake

@@ -16,7 +16,7 @@ endif()
 # Source package, for "make package_source"
 # ----------------------------------------------------------------------------
 if(BUILD_PACKAGE)
-  set(TARBALL_NAME "${CMAKE_PROJECT_NAME}-${OPENCV_VERSION_MAJOR}.${OPENCV_VERSION_MINOR}.${OPENCV_VERSION_PATCH}")
+  set(TARBALL_NAME "${CMAKE_PROJECT_NAME}-${OPENCV_VERSION}")
   if (NOT WIN32)
     if(APPLE)
       set(TAR_CMD gnutar)

cmake/OpenCVFindLibsVideo.cmake

@@ -85,11 +85,12 @@ if(WITH_XINE)
 endif(WITH_XINE)
 
 # --- V4L ---
-ocv_clear_vars(HAVE_LIBV4L HAVE_CAMV4L HAVE_CAMV4L2)
+ocv_clear_vars(HAVE_LIBV4L HAVE_CAMV4L HAVE_CAMV4L2 HAVE_VIDEOIO)
 if(WITH_V4L)
   CHECK_MODULE(libv4l1 HAVE_LIBV4L)
   CHECK_INCLUDE_FILE(linux/videodev.h HAVE_CAMV4L)
   CHECK_INCLUDE_FILE(linux/videodev2.h HAVE_CAMV4L2)
+  CHECK_INCLUDE_FILE(sys/videoio.h HAVE_VIDEOIO)
 endif(WITH_V4L)
 
 # --- OpenNI ---

cmake/OpenCVGenAndroidMK.cmake

@@ -71,6 +71,12 @@ if(ANDROID)
   endforeach()
   string(REPLACE "opencv_" "" OPENCV_MODULES_CONFIGMAKE "${OPENCV_MODULES_CONFIGMAKE}")
 
+  # prepare 3rd-party component list without TBB for armeabi and mips platforms. TBB is useless there.
+  set(OPENCV_3RDPARTY_COMPONENTS_CONFIGMAKE_NO_TBB ${OPENCV_3RDPARTY_COMPONENTS_CONFIGMAKE})
+  foreach(mod ${OPENCV_3RDPARTY_COMPONENTS_CONFIGMAKE_NO_TBB})
+     string(REPLACE "tbb" "" OPENCV_3RDPARTY_COMPONENTS_CONFIGMAKE_NO_TBB "${OPENCV_3RDPARTY_COMPONENTS_CONFIGMAKE_NO_TBB}")
+  endforeach()
+
   if(BUILD_FAT_JAVA_LIB)
     set(OPENCV_LIBS_CONFIGMAKE java)
   else()

cmake/OpenCVModule.cmake

@@ -164,6 +164,9 @@ macro(ocv_module_disable module)
   set(HAVE_${__modname} OFF CACHE INTERNAL "Module ${__modname} can not be built in current configuration")
   set(OPENCV_MODULE_${__modname}_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}" CACHE INTERNAL "Location of ${__modname} module sources")
   set(OPENCV_MODULES_DISABLED_FORCE "${OPENCV_MODULES_DISABLED_FORCE}" CACHE INTERNAL "List of OpenCV modules which can not be build in current configuration")
+  if(BUILD_${__modname})
+    # touch variable controlling build of the module to suppress "unused variable" CMake warning
+  endif()
   unset(__modname)
   return() # leave the current folder
 endmacro()
@@ -171,6 +174,7 @@ endmacro()
 
 # Internal macro; partly disables OpenCV module
 macro(__ocv_module_turn_off the_module)
+  list(REMOVE_ITEM OPENCV_MODULES_DISABLED_AUTO "${the_module}")
   list(APPEND OPENCV_MODULES_DISABLED_AUTO "${the_module}")
   list(REMOVE_ITEM OPENCV_MODULES_BUILD "${the_module}")
   list(REMOVE_ITEM OPENCV_MODULES_PUBLIC "${the_module}")
@@ -190,7 +194,7 @@ macro(__ocv_flatten_module_required_dependencies the_module)
       break()
     elseif(";${OPENCV_MODULES_DISABLED_USER};${OPENCV_MODULES_DISABLED_AUTO};" MATCHES ";${__dep};")
       __ocv_module_turn_off(${the_module}) # depends on disabled module
-      break()
+      list(APPEND __flattened_deps "${__dep}")
     elseif(";${OPENCV_MODULES_BUILD};" MATCHES ";${__dep};")
       if(";${__resolved_deps};" MATCHES ";${__dep};")
         list(APPEND __flattened_deps "${__dep}") # all dependencies of this module are already resolved
@@ -259,6 +263,7 @@ macro(__ocv_flatten_module_dependencies)
   foreach(m ${OPENCV_MODULES_BUILD})
     set(HAVE_${m} ON CACHE INTERNAL "Module ${m} will be built in current configuration")
     __ocv_flatten_module_required_dependencies(${m})
+    set(OPENCV_MODULE_${m}_DEPS ${OPENCV_MODULE_${m}_DEPS} CACHE INTERNAL "Flattened required dependencies of ${m} module")
   endforeach()
 
   foreach(m ${OPENCV_MODULES_BUILD})
@@ -283,7 +288,7 @@ macro(__ocv_flatten_module_dependencies)
   ocv_list_unique(OPENCV_MODULES_BUILD_)
 
   set(OPENCV_MODULES_PUBLIC        ${OPENCV_MODULES_PUBLIC}        CACHE INTERNAL "List of OpenCV modules marked for export")
-  set(OPENCV_MODULES_BUILD         ${OPENCV_MODULES_BUILD_}         CACHE INTERNAL "List of OpenCV modules included into the build")
+  set(OPENCV_MODULES_BUILD         ${OPENCV_MODULES_BUILD_}        CACHE INTERNAL "List of OpenCV modules included into the build")
   set(OPENCV_MODULES_DISABLED_AUTO ${OPENCV_MODULES_DISABLED_AUTO} CACHE INTERNAL "List of OpenCV modules implicitly disabled due to dependencies")
 endmacro()
 
@@ -456,6 +461,7 @@ macro(ocv_create_module)
     OUTPUT_NAME "${the_module}${OPENCV_DLLVERSION}"
     DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
     ARCHIVE_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
+    LIBRARY_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
     RUNTIME_OUTPUT_DIRECTORY ${EXECUTABLE_OUTPUT_PATH}
     INSTALL_NAME_DIR lib
   )
@@ -465,7 +471,7 @@ macro(ocv_create_module)
     # Android SDK build scripts can include only .so files into final .apk
     # As result we should not set version properties for Android
     set_target_properties(${the_module} PROPERTIES
-      VERSION ${OPENCV_VERSION}
+      VERSION ${OPENCV_LIBVERSION}
       SOVERSION ${OPENCV_SOVERSION}
     )
   endif()

cmake/OpenCVPCHSupport.cmake

@@ -19,7 +19,7 @@ IF(CMAKE_COMPILER_IS_GNUCXX)
         ARGS ${CMAKE_CXX_COMPILER_ARG1} -dumpversion
         OUTPUT_VARIABLE gcc_compiler_version)
     #MESSAGE("GCC Version: ${gcc_compiler_version}")
-    IF(gcc_compiler_version MATCHES "4\\.[0,2-9]\\.[0-9x]")
+    IF(gcc_compiler_version VERSION_GREATER "4.2.-1")
         SET(PCHSupport_FOUND TRUE)
     ENDIF()
 

cmake/OpenCVUtils.cmake

@@ -64,6 +64,13 @@ MACRO(ocv_check_compiler_flag LANG FLAG RESULT)
       else()
         FILE(WRITE "${_fname}" "#pragma\nint main(void) { return 0; }\n")
       endif()
+    elseif("_${LANG}_" MATCHES "_OBJCXX_")
+      set(_fname "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.mm")
+      if("${CMAKE_CXX_FLAGS} ${FLAG} " MATCHES "-Werror " OR "${CMAKE_CXX_FLAGS} ${FLAG} " MATCHES "-Werror=unknown-pragmas ")
+        FILE(WRITE "${_fname}" "int main() { return 0; }\n")
+      else()
+        FILE(WRITE "${_fname}" "#pragma\nint main() { return 0; }\n")
+      endif()
     else()
       unset(_fname)
     endif()
@@ -100,6 +107,8 @@ macro(ocv_check_flag_support lang flag varname)
     set(_lang CXX)
   elseif("_${lang}_" MATCHES "_C_")
     set(_lang C)
+  elseif("_${lang}_" MATCHES "_OBJCXX_")
+    set(_lang OBJCXX)
   else()
     set(_lang ${lang})
   endif()

cmake/OpenCVVersion.cmake

@@ -1,12 +1,18 @@
 SET(OPENCV_VERSION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/modules/core/include/opencv2/core/version.hpp")
-FILE(STRINGS "${OPENCV_VERSION_FILE}" OPENCV_VERSION_PARTS REGEX "#define CV_.+OR_VERSION[ ]+[0-9]+" )
+FILE(STRINGS "${OPENCV_VERSION_FILE}" OPENCV_VERSION_PARTS REGEX "#define CV_VERSION_[A-Z]+[ ]+[0-9]+" )
 
-string(REGEX REPLACE ".+CV_MAJOR_VERSION[ ]+([0-9]+).*" "\\1" OPENCV_VERSION_MAJOR "${OPENCV_VERSION_PARTS}")
-string(REGEX REPLACE ".+CV_MINOR_VERSION[ ]+([0-9]+).*" "\\1" OPENCV_VERSION_MINOR "${OPENCV_VERSION_PARTS}")
-string(REGEX REPLACE ".+CV_SUBMINOR_VERSION[ ]+([0-9]+).*" "\\1" OPENCV_VERSION_PATCH "${OPENCV_VERSION_PARTS}")
+string(REGEX REPLACE ".+CV_VERSION_EPOCH[ ]+([0-9]+).*" "\\1" OPENCV_VERSION_MAJOR "${OPENCV_VERSION_PARTS}")
+string(REGEX REPLACE ".+CV_VERSION_MAJOR[ ]+([0-9]+).*" "\\1" OPENCV_VERSION_MINOR "${OPENCV_VERSION_PARTS}")
+string(REGEX REPLACE ".+CV_VERSION_MINOR[ ]+([0-9]+).*" "\\1" OPENCV_VERSION_PATCH "${OPENCV_VERSION_PARTS}")
+string(REGEX REPLACE ".+CV_VERSION_REVISION[ ]+([0-9]+).*" "\\1" OPENCV_VERSION_TWEAK "${OPENCV_VERSION_PARTS}")
 
 set(OPENCV_VERSION "${OPENCV_VERSION_MAJOR}.${OPENCV_VERSION_MINOR}.${OPENCV_VERSION_PATCH}")
+if(OPENCV_VERSION_TWEAK GREATER 0)
+  set(OPENCV_VERSION "${OPENCV_VERSION}.${OPENCV_VERSION_TWEAK}")
+endif()
+
 set(OPENCV_SOVERSION "${OPENCV_VERSION_MAJOR}.${OPENCV_VERSION_MINOR}")
+set(OPENCV_LIBVERSION "${OPENCV_VERSION_MAJOR}.${OPENCV_VERSION_MINOR}.${OPENCV_VERSION_PATCH}")
 
 # create a dependency on version file
 # we never use output of the following command but cmake will rerun automatically if the version file changes

cmake/templates/OpenCV.mk.in

@@ -29,8 +29,22 @@ ifeq ($(OPENCV_LIB_TYPE),SHARED)
     OPENCV_3RDPARTY_COMPONENTS:=
     OPENCV_EXTRA_COMPONENTS:=
 else
-    OPENCV_3RDPARTY_COMPONENTS:=@OPENCV_3RDPARTY_COMPONENTS_CONFIGMAKE@
-    OPENCV_EXTRA_COMPONENTS:=@OPENCV_EXTRA_COMPONENTS_CONFIGMAKE@
+    ifeq ($(TARGET_ARCH_ABI),armeabi-v7a)
+        OPENCV_3RDPARTY_COMPONENTS:=@OPENCV_3RDPARTY_COMPONENTS_CONFIGMAKE@
+        OPENCV_EXTRA_COMPONENTS:=@OPENCV_EXTRA_COMPONENTS_CONFIGMAKE@
+    endif
+    ifeq ($(TARGET_ARCH_ABI),x86)
+        OPENCV_3RDPARTY_COMPONENTS:=@OPENCV_3RDPARTY_COMPONENTS_CONFIGMAKE@
+        OPENCV_EXTRA_COMPONENTS:=@OPENCV_EXTRA_COMPONENTS_CONFIGMAKE@
+    endif
+    ifeq ($(TARGET_ARCH_ABI),armeabi)
+        OPENCV_3RDPARTY_COMPONENTS:=@OPENCV_3RDPARTY_COMPONENTS_CONFIGMAKE_NO_TBB@
+        OPENCV_EXTRA_COMPONENTS:=@OPENCV_EXTRA_COMPONENTS_CONFIGMAKE@
+    endif
+    ifeq ($(TARGET_ARCH_ABI),mips)
+        OPENCV_3RDPARTY_COMPONENTS:=@OPENCV_3RDPARTY_COMPONENTS_CONFIGMAKE_NO_TBB@
+        OPENCV_EXTRA_COMPONENTS:=@OPENCV_EXTRA_COMPONENTS_CONFIGMAKE@
+    endif
 endif
 
 ifeq (${OPENCV_CAMERA_MODULES},on)
@@ -75,14 +89,20 @@ define add_opencv_camera_module
     include $(PREBUILT_SHARED_LIBRARY)
 endef
 
-ifeq ($(OPENCV_INSTALL_MODULES),on)
-$(foreach module,$(OPENCV_LIBS),$(eval $(call add_opencv_module,$(module))))
-endif
-$(foreach module,$(OPENCV_3RDPARTY_COMPONENTS),$(eval $(call add_opencv_3rdparty_component,$(module))))
-$(foreach module,$(OPENCV_CAMERA_MODULES),$(eval $(call add_opencv_camera_module,$(module))))
+ifeq ($(OPENCV_MK_ALREADY_INCLUDED),)
+    ifeq ($(OPENCV_INSTALL_MODULES),on)
+        $(foreach module,$(OPENCV_LIBS),$(eval $(call add_opencv_module,$(module))))
+    endif
 
-ifneq ($(OPENCV_BASEDIR),)
-    OPENCV_LOCAL_C_INCLUDES += $(foreach mod, $(OPENCV_MODULES), $(OPENCV_BASEDIR)/modules/$(mod)/include)
+    $(foreach module,$(OPENCV_3RDPARTY_COMPONENTS),$(eval $(call add_opencv_3rdparty_component,$(module))))
+    $(foreach module,$(OPENCV_CAMERA_MODULES),$(eval $(call add_opencv_camera_module,$(module))))
+
+    ifneq ($(OPENCV_BASEDIR),)
+        OPENCV_LOCAL_C_INCLUDES += $(foreach mod, $(OPENCV_MODULES), $(OPENCV_BASEDIR)/modules/$(mod)/include)
+    endif
+
+    #turn off module installation to prevent their redefinition
+    OPENCV_MK_ALREADY_INCLUDED:=on
 endif
 
 ifeq ($(OPENCV_LOCAL_CFLAGS),)

cmake/templates/OpenCVConfig.cmake.in

@@ -22,10 +22,11 @@
 #      - OpenCV_INCLUDE_DIRS             : The OpenCV include directories.
 #      - OpenCV_COMPUTE_CAPABILITIES     : The version of compute capability
 #      - OpenCV_ANDROID_NATIVE_API_LEVEL : Minimum required level of Android API
-#      - OpenCV_VERSION                  : The version of this OpenCV build. Example: "@OPENCV_VERSION@"
-#      - OpenCV_VERSION_MAJOR            : Major version part of OpenCV_VERSION. Example: "@OPENCV_VERSION_MAJOR@"
-#      - OpenCV_VERSION_MINOR            : Minor version part of OpenCV_VERSION. Example: "@OPENCV_VERSION_MINOR@"
-#      - OpenCV_VERSION_PATCH            : Patch version part of OpenCV_VERSION. Example: "@OPENCV_VERSION_PATCH@"
+#      - OpenCV_VERSION                  : The version of this OpenCV build: "@OPENCV_VERSION@"
+#      - OpenCV_VERSION_MAJOR            : Major version part of OpenCV_VERSION: "@OPENCV_VERSION_MAJOR@"
+#      - OpenCV_VERSION_MINOR            : Minor version part of OpenCV_VERSION: "@OPENCV_VERSION_MINOR@"
+#      - OpenCV_VERSION_PATCH            : Patch version part of OpenCV_VERSION: "@OPENCV_VERSION_PATCH@"
+#      - OpenCV_VERSION_TWEAK            : Tweak version part of OpenCV_VERSION: "@OPENCV_VERSION_TWEAK@"
 #
 #    Advanced variables:
 #      - OpenCV_SHARED
@@ -41,8 +42,9 @@
 set(OpenCV_COMPUTE_CAPABILITIES @OpenCV_CUDA_CC_CONFIGCMAKE@)
 
 set(OpenCV_CUDA_VERSION @OpenCV_CUDA_VERSION@)
-set(OpenCV_USE_CUBLAS @HAVE_CUBLAS@)
-set(OpenCV_USE_CUFFT  @HAVE_CUFFT@)
+set(OpenCV_USE_CUBLAS   @HAVE_CUBLAS@)
+set(OpenCV_USE_CUFFT    @HAVE_CUFFT@)
+set(OpenCV_USE_NVCUVID  @HAVE_NVCUVID@)
 
 # Android API level from which OpenCV has been compiled is remembered
 set(OpenCV_ANDROID_NATIVE_API_LEVEL @OpenCV_ANDROID_NATIVE_API_LEVEL_CONFIGCMAKE@)
@@ -99,6 +101,7 @@ SET(OpenCV_VERSION @OPENCV_VERSION@)
 SET(OpenCV_VERSION_MAJOR  @OPENCV_VERSION_MAJOR@)
 SET(OpenCV_VERSION_MINOR  @OPENCV_VERSION_MINOR@)
 SET(OpenCV_VERSION_PATCH  @OPENCV_VERSION_PATCH@)
+SET(OpenCV_VERSION_TWEAK  @OPENCV_VERSION_TWEAK@)
 
 # ====================================================================
 # Link libraries: e.g.   libopencv_core.so, opencv_imgproc220d.lib, etc...
@@ -183,7 +186,7 @@ set(OpenCV_FIND_COMPONENTS ${OpenCV_FIND_COMPONENTS_})
 #  Resolve dependencies
 # ==============================================================
 if(OpenCV_USE_MANGLED_PATHS)
-  set(OpenCV_LIB_SUFFIX ".${OpenCV_VERSION}")
+  set(OpenCV_LIB_SUFFIX ".${OpenCV_VERSION_MAJOR}.${OpenCV_VERSION_MINOR}.${OpenCV_VERSION_PATCH}")
 else()
   set(OpenCV_LIB_SUFFIX "")
 endif()
@@ -216,17 +219,22 @@ foreach(__opttype OPT DBG)
   else()
     #TODO: duplicates are annoying but they should not be the problem
   endif()
-  # fix hard coded paths for CUDA libraries under Windows
-  if(WIN32 AND OpenCV_CUDA_VERSION AND NOT OpenCV_SHARED)
+  
+  # CUDA
+  if(OpenCV_CUDA_VERSION AND (CARMA OR (WIN32 AND NOT OpenCV_SHARED)))
     if(NOT CUDA_FOUND)
       find_package(CUDA ${OpenCV_CUDA_VERSION} EXACT REQUIRED)
     else()
       if(NOT CUDA_VERSION_STRING VERSION_EQUAL OpenCV_CUDA_VERSION)
-        message(FATAL_ERROR "OpenCV static library compiled with CUDA ${OpenCV_CUDA_VERSION} support. Please, use the same version or rebuild OpenCV with CUDA ${CUDA_VERSION_STRING}")
+        if(WIN32)
+          message(FATAL_ERROR "OpenCV static library was compiled with CUDA ${OpenCV_CUDA_VERSION} support. Please, use the same version or rebuild OpenCV with CUDA ${CUDA_VERSION_STRING}")
+        else()
+          message(FATAL_ERROR "OpenCV library for CARMA was compiled with CUDA ${OpenCV_CUDA_VERSION} support. Please, use the same version or rebuild OpenCV with CUDA ${CUDA_VERSION_STRING}")
+        endif()
       endif()
     endif()
 
-    list(APPEND OpenCV_EXTRA_LIBS_${__opttype} ${CUDA_LIBRARIES} ${CUDA_npp_LIBRARY} ${CUDA_nvcuvid_LIBRARY} ${CUDA_nvcuvenc_LIBRARY})
+    list(APPEND OpenCV_EXTRA_LIBS_${__opttype} ${CUDA_LIBRARIES} ${CUDA_npp_LIBRARY})
 
     if(OpenCV_USE_CUBLAS)
       list(APPEND OpenCV_EXTRA_LIBS_${__opttype} ${CUDA_CUBLAS_LIBRARIES})
@@ -236,6 +244,13 @@ foreach(__opttype OPT DBG)
       list(APPEND OpenCV_EXTRA_LIBS_${__opttype} ${CUDA_CUFFT_LIBRARIES})
     endif()
 
+    if(OpenCV_USE_NVCUVID)
+      list(APPEND OpenCV_EXTRA_LIBS_${__opttype} ${CUDA_nvcuvid_LIBRARIES})
+    endif()
+
+    if(WIN32)
+      list(APPEND OpenCV_EXTRA_LIBS_${__opttype} ${CUDA_nvcuvenc_LIBRARIES})
+    endif()
   endif()
 endforeach()
 

cmake/templates/cvconfig.h.cmake

@@ -19,6 +19,9 @@
 /* V4L2 capturing support */
 #cmakedefine HAVE_CAMV4L2
 
+/* V4L2 capturing support in videoio.h */
+#cmakedefine HAVE_VIDEOIO
+
 /* V4L/V4L2 capturing support via libv4l */
 #cmakedefine HAVE_LIBV4L
 
@@ -175,21 +178,15 @@
 /* NVidia Cuda Runtime API*/
 #cmakedefine HAVE_CUDA
 
-/* OpenCL Support */
-#cmakedefine HAVE_OPENCL
-
-/* AMD's OpenCL Fast Fourier Transform Library*/
-#cmakedefine HAVE_CLAMDFFT
-
-/* AMD's Basic Linear Algebra Subprograms Library*/
-#cmakedefine HAVE_CLAMDBLAS
-
 /* NVidia Cuda Fast Fourier Transform (FFT) API*/
 #cmakedefine HAVE_CUFFT
 
 /* NVidia Cuda Basic Linear Algebra Subprograms (BLAS) API*/
 #cmakedefine HAVE_CUBLAS
 
+/* NVidia Video Decoding API*/
+#cmakedefine HAVE_NVCUVID
+
 /* Compile for 'real' NVIDIA GPU architectures */
 #define CUDA_ARCH_BIN "${OPENCV_CUDA_ARCH_BIN}"
 
@@ -202,6 +199,15 @@
 /* Create PTX or BIN for 1.0 compute capability */
 #cmakedefine CUDA_ARCH_BIN_OR_PTX_10
 
+/* OpenCL Support */
+#cmakedefine HAVE_OPENCL
+
+/* AMD's OpenCL Fast Fourier Transform Library*/
+#cmakedefine HAVE_CLAMDFFT
+
+/* AMD's Basic Linear Algebra Subprograms Library*/
+#cmakedefine HAVE_CLAMDBLAS
+
 /* VideoInput library */
 #cmakedefine HAVE_VIDEOINPUT
 

doc/CMakeLists.txt

@@ -2,8 +2,6 @@
 #  CMake file for OpenCV docs
 #
 
-file(GLOB FILES_DOC *.htm *.txt *.jpg *.png *.pdf)
-file(GLOB FILES_DOC_VS vidsurv/*.doc)
 file(GLOB FILES_TEX *.tex *.sty *.bib)
 file(GLOB FILES_TEX_PICS pics/*.png pics/*.jpg)
 
@@ -11,6 +9,14 @@ if(BUILD_DOCS AND HAVE_SPHINX)
 
   project(opencv_docs)
 
+  set(DOC_LIST "${OpenCV_SOURCE_DIR}/doc/opencv-logo.png" "${OpenCV_SOURCE_DIR}/doc/opencv-logo2.png"
+               "${OpenCV_SOURCE_DIR}/doc/opencv-logo-white.png" "${OpenCV_SOURCE_DIR}/doc/opencv.ico"
+               "${OpenCV_SOURCE_DIR}/doc/haartraining.htm" "${OpenCV_SOURCE_DIR}/doc/license.txt"
+               "${OpenCV_SOURCE_DIR}/doc/pattern.png" "${OpenCV_SOURCE_DIR}/doc/acircles_pattern.png")
+
+  set(OPTIONAL_DOC_LIST "")
+
+
   set(OPENCV2_BASE_MODULES core imgproc highgui video calib3d features2d objdetect ml flann gpu photo stitching nonfree contrib legacy)
 
   # build lists of modules to be documented
@@ -54,7 +60,7 @@ if(BUILD_DOCS AND HAVE_SPHINX)
 
   configure_file("${OpenCV_SOURCE_DIR}/modules/refman.rst.in" "${OpenCV_SOURCE_DIR}/modules/refman.rst" IMMEDIATE @ONLY)
 
-  file(GLOB_RECURSE OPENCV_FILES_UG user_guide/*.rst)
+  file(GLOB_RECURSE OPENCV_FILES_UG  user_guide/*.rst)
   file(GLOB_RECURSE OPENCV_FILES_TUT tutorials/*.rst)
   file(GLOB_RECURSE OPENCV_FILES_TUT_PICT tutorials/*.png tutorials/*.jpg)
 
@@ -68,19 +74,29 @@ if(BUILD_DOCS AND HAVE_SPHINX)
       COMMAND ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_CURRENT_SOURCE_DIR}/mymath.sty ${CMAKE_CURRENT_BINARY_DIR}
       COMMAND ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/patch_refman_latex.py" opencv2refman.tex
       COMMAND ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/patch_refman_latex.py" opencv2manager.tex
-      COMMAND ${PDFLATEX_COMPILER} opencv2refman.tex
-      COMMAND ${PDFLATEX_COMPILER} opencv2refman.tex
-      COMMAND ${PDFLATEX_COMPILER} opencv2manager.tex
-      COMMAND ${PDFLATEX_COMPILER} opencv2manager.tex
-      COMMAND ${PDFLATEX_COMPILER} opencv_user.tex
-      COMMAND ${PDFLATEX_COMPILER} opencv_user.tex
-      COMMAND ${PDFLATEX_COMPILER} opencv_tutorials.tex
-      COMMAND ${PDFLATEX_COMPILER} opencv_tutorials.tex
+      COMMAND ${CMAKE_COMMAND} -E echo "Generating opencv2refman.pdf"
+      COMMAND ${PDFLATEX_COMPILER} -interaction=batchmode opencv2refman.tex
+      COMMAND ${PDFLATEX_COMPILER} -interaction=batchmode opencv2refman.tex
+      COMMAND ${CMAKE_COMMAND} -E echo "Generating opencv2manager.pdf"
+      COMMAND ${PDFLATEX_COMPILER} -interaction=batchmode opencv2manager.tex
+      COMMAND ${PDFLATEX_COMPILER} -interaction=batchmode opencv2manager.tex
+      COMMAND ${CMAKE_COMMAND} -E echo "Generating opencv_user.pdf"
+      COMMAND ${PDFLATEX_COMPILER} -interaction=batchmode opencv_user.tex
+      COMMAND ${PDFLATEX_COMPILER} -interaction=batchmode opencv_user.tex
+      COMMAND ${CMAKE_COMMAND} -E echo "Generating opencv_tutorials.pdf"
+      COMMAND ${PDFLATEX_COMPILER} -interaction=batchmode opencv_tutorials.tex
+      COMMAND ${PDFLATEX_COMPILER} -interaction=batchmode opencv_tutorials.tex
+      COMMAND ${CMAKE_COMMAND} -E echo "Generating opencv_cheatsheet.pdf"
+      COMMAND ${PDFLATEX_COMPILER} -interaction=batchmode "${CMAKE_CURRENT_SOURCE_DIR}/opencv_cheatsheet.tex"
+      COMMAND ${PDFLATEX_COMPILER} -interaction=batchmode "${CMAKE_CURRENT_SOURCE_DIR}/opencv_cheatsheet.tex"
       DEPENDS ${OPENCV_DOC_DEPS}
       WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
       COMMENT "Generating the PDF Manuals"
       )
 
+    LIST(APPEND OPTIONAL_DOC_LIST "${CMAKE_BINARY_DIR}/doc/opencv2refman.pdf" "${CMAKE_BINARY_DIR}/doc/opencv2manager.pdf"
+          "${CMAKE_BINARY_DIR}/doc/opencv_user.pdf" "${CMAKE_BINARY_DIR}/doc/opencv_tutorials.pdf" "${CMAKE_BINARY_DIR}/doc/opencv_cheatsheet.pdf")
+
     if(ENABLE_SOLUTION_FOLDERS)
       set_target_properties(docs PROPERTIES FOLDER "documentation")
     endif()
@@ -97,7 +113,13 @@ if(BUILD_DOCS AND HAVE_SPHINX)
   if(ENABLE_SOLUTION_FOLDERS)
     set_target_properties(html_docs PROPERTIES FOLDER "documentation")
   endif()
-endif()
 
-install(FILES ${FILES_DOC} DESTINATION "${OPENCV_DOC_INSTALL_PATH}" COMPONENT main)
-install(FILES ${FILES_DOC_VS} DESTINATION "${OPENCV_DOC_INSTALL_PATH}/vidsurv" COMPONENT main)
+  foreach(f ${DOC_LIST})
+    install(FILES "${f}" DESTINATION "${OPENCV_DOC_INSTALL_PATH}" COMPONENT main)
+  endforeach()
+
+  foreach(f ${OPTIONAL_DOC_LIST})
+    install(FILES "${f}" DESTINATION "${OPENCV_DOC_INSTALL_PATH}" OPTIONAL)
+  endforeach()
+
+endif()

doc/_themes/blue/static/default.css_t

@@ -394,4 +394,12 @@ div.body ul.search li {
 div.linenodiv {
     min-width: 1em;
     text-align: right;
+}
+
+div.sphinxsidebar #searchbox input[type="text"] {
+    width:auto;
+}
+
+div.sphinxsidebar #searchbox input[type="submit"] {
+    width:auto;
 }

doc/check_docs.py

@@ -1,3 +1,5 @@
+#/usr/bin/env python
+
 import sys, glob
 
 sys.path.append("../modules/python/src2/")

doc/check_docs2.py

@@ -1,3 +1,5 @@
+#/usr/bin/env python
+
 import os, sys, fnmatch, re
 
 sys.path.append("../modules/python/src2/")
@@ -114,6 +116,8 @@ def compareSignatures(f, s):
         sarg = arg[1]
         ftype = re.sub(r"\b(cv|std)::", "", (farg[0] or ""))
         stype = re.sub(r"\b(cv|std)::", "", (sarg[0] or ""))
+        ftype = re.sub(r"\s+(\*|&)$", "\\1", ftype)
+        stype = re.sub(r"\s+(\*|&)$", "\\1", stype)
         if ftype != stype:
             return False, "type of argument #" + str(idx+1) + " mismatch"
         fname = farg[1] or "arg" + str(idx)
@@ -149,6 +153,7 @@ def formatSignature(s):
             if idx > 0:
                 _str += ", "
             argtype = re.sub(r"\bcv::", "", arg[0])
+            argtype = re.sub(r"\s+(\*|&)$", "\\1", arg[0])
             bidx = argtype.find('[')
             if bidx < 0:
                 _str += argtype + " "

doc/conf.py

@@ -1,3 +1,5 @@
+#/usr/bin/env python
+
 # -*- coding: utf-8 -*-
 #
 # opencvstd documentation build configuration file, created by
@@ -42,21 +44,24 @@ master_doc = 'index'
 
 # General information about the project.
 project = u'OpenCV'
-copyright = u'2011-2012, opencv dev team'
+copyright = u'2011-2013, opencv dev team'
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
 # built documents.
 
 version_file = open("../modules/core/include/opencv2/core/version.hpp", "rt").read()
-version_major = re.search("^W*#\W*define\W+CV_MAJOR_VERSION\W+(\d+)\W*$", version_file, re.MULTILINE).group(1)
-version_minor = re.search("^W*#\W*define\W+CV_MINOR_VERSION\W+(\d+)\W*$", version_file, re.MULTILINE).group(1)
-version_patch = re.search("^W*#\W*define\W+CV_SUBMINOR_VERSION\W+(\d+)\W*$", version_file, re.MULTILINE).group(1)
+version_epoch = re.search("^W*#\W*define\W+CV_VERSION_EPOCH\W+(\d+)\W*$", version_file, re.MULTILINE).group(1)
+version_major = re.search("^W*#\W*define\W+CV_VERSION_MAJOR\W+(\d+)\W*$", version_file, re.MULTILINE).group(1)
+version_minor = re.search("^W*#\W*define\W+CV_VERSION_MINOR\W+(\d+)\W*$", version_file, re.MULTILINE).group(1)
+version_patch = re.search("^W*#\W*define\W+CV_VERSION_REVISION\W+(\d+)\W*$", version_file, re.MULTILINE).group(1)
 
 # The short X.Y version.
-version = version_major + '.' + version_minor
+version = version_epoch + '.' + version_major
 # The full version, including alpha/beta/rc tags.
-release = version_major + '.' + version_minor + '.' + version_patch
+release = version_epoch + '.' + version_major + '.' + version_minor
+if version_patch:
+    release = release + '.' + version_patch
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
@@ -293,7 +298,7 @@ extlinks = {
             'svms':('http://opencv.itseez.com/modules/ml/doc/support_vector_machines.html#%s', None),
             'drawingfunc':('http://opencv.itseez.com/modules/core/doc/drawing_functions.html#%s', None),
             'xmlymlpers':('http://opencv.itseez.com/modules/core/doc/xml_yaml_persistence.html#%s', None),
-            'huivideo' : ('http://opencv.itseez.com/modules/highgui/doc/reading_and_writing_images_and_video.html#%s', None),
+            'hgvideo' : ('http://opencv.itseez.com/modules/highgui/doc/reading_and_writing_images_and_video.html#%s', None),
             'gpuinit' : ('http://opencv.itseez.com/modules/gpu/doc/initalization_and_information.html#%s', None),
             'gpudatastructure' : ('http://opencv.itseez.com/modules/gpu/doc/data_structures.html#%s', None),
             'gpuopmatrices' : ('http://opencv.itseez.com/modules/gpu/doc/operations_on_matrices.html#%s', None),

doc/ocv.py

@@ -1,3 +1,4 @@
+#/usr/bin/env python
 # -*- coding: utf-8 -*-
 """
     ocv domain, a modified copy of sphinx.domains.cpp + shpinx.domains.python.

doc/opencv_cheatsheet.tex

@@ -67,6 +67,7 @@
 \usepackage[pdftex]{color,graphicx}
 \usepackage[landscape]{geometry}
 \usepackage{hyperref}
+\usepackage[T1]{fontenc}
 \hypersetup{colorlinks=true, filecolor=black, linkcolor=black, urlcolor=blue, citecolor=black}
 \graphicspath{{./images/}}
 
@@ -214,7 +215,7 @@
 \> \texttt{for(int y = 1; y < image.rows-1; y++) \{}\\
 \> \> \texttt{Vec3b* prevRow = image.ptr<Vec3b>(y-1);}\\
 \> \> \texttt{Vec3b* nextRow = image.ptr<Vec3b>(y+1);}\\
-\> \> \texttt{for(int x = 0; y < image.cols; x++)}\\
+\> \> \texttt{for(int x = 0; x < image.cols; x++)}\\
 \> \> \> \texttt{for(int c = 0; c < 3; c++)}\\
 \> \> \> \texttt{  dyImage.at<Vec3b>(y,x)[c] =}\\
 \> \> \> \texttt{    saturate\_cast<uchar>(}\\

doc/patch_refman_latex.py

@@ -1,3 +1,5 @@
+#/usr/bin/env python
+
 import sys
 
 f=open(sys.argv[1], "rt")

doc/pattern_tools/gen_pattern.py

@@ -1,3 +1,5 @@
+#/usr/bin/env python
+
 """gen_pattern.py
 To run:
 -c 10 -r 12 -o out.svg

doc/pattern_tools/svgfig.py

@@ -1,3 +1,5 @@
+#/usr/bin/env python
+
 # svgfig.py copyright (C) 2008 Jim Pivarski <jpivarski@gmail.com>
 #
 # This program is free software; you can redistribute it and/or

doc/reformat.py

@@ -1,3 +1,5 @@
+#/usr/bin/env python
+
 import os, sys, re
 
 finput=open(sys.argv[1], "rt")