Fixed Android build

2f409055 · Andrey Kamaev · ec0ec693 · 2f409055 · 2f409055 · 2f409055
22 changed file
--- a/3rdparty/libjpeg/CMakeLists.txt
+++ b/3rdparty/libjpeg/CMakeLists.txt
@@ -25,6 +25,8 @@ if(CMAKE_COMPILER_IS_GNUCXX)
  set_source_files_properties(jcdctmgr.c PROPERTIES COMPILE_FLAGS "-O1")
 endif()

+ocv_warnings_disable(CMAKE_C_FLAGS -Wcast-align)
+
 set_target_properties(${JPEG_LIBRARY}
  PROPERTIES OUTPUT_NAME ${JPEG_LIBRARY}
  DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"

--- a/3rdparty/libpng/CMakeLists.txt
+++ b/3rdparty/libpng/CMakeLists.txt
@@ -21,6 +21,8 @@ if(UNIX)
  endif()
 endif()

+ocv_warnings_disable(CMAKE_C_FLAGS -Wcast-align)
+
 set_target_properties(${PNG_LIBRARY}
  PROPERTIES OUTPUT_NAME ${PNG_LIBRARY}
  DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"

--- a/3rdparty/libtiff/CMakeLists.txt
+++ b/3rdparty/libtiff/CMakeLists.txt
@@ -90,7 +90,7 @@ if(WIN32)
  list(APPEND lib_srcs tif_win32.c)
 endif(WIN32)

-ocv_warnings_disable(CMAKE_C_FLAGS -Wno-unused-but-set-variable -Wmissing-prototypes -Wmissing-declarations -Wundef)
+ocv_warnings_disable(CMAKE_C_FLAGS -Wno-unused-but-set-variable -Wmissing-prototypes -Wmissing-declarations -Wundef -Wcast-align)
 ocv_warnings_disable(CMAKE_CXX_FLAGS -Wmissing-declarations)

 if(UNIX AND (CMAKE_COMPILER_IS_GNUCXX OR CV_ICC))

--- a/cmake/OpenCVCompilerOptions.cmake
+++ b/cmake/OpenCVCompilerOptions.cmake
@@ -21,76 +21,102 @@ if(MSVC)
  endif()
 endif()

+set(OPENCV_EXTRA_FLAGS "")
 set(OPENCV_EXTRA_C_FLAGS "")
-set(OPENCV_EXTRA_C_FLAGS_RELEASE "")
-set(OPENCV_EXTRA_C_FLAGS_DEBUG "")
+set(OPENCV_EXTRA_CXX_FLAGS "")
+set(OPENCV_EXTRA_FLAGS_RELEASE "")
+set(OPENCV_EXTRA_FLAGS_DEBUG "")
 set(OPENCV_EXTRA_EXE_LINKER_FLAGS "")
 set(OPENCV_EXTRA_EXE_LINKER_FLAGS_RELEASE "")
 set(OPENCV_EXTRA_EXE_LINKER_FLAGS_DEBUG "")

+macro(add_extra_compiler_option option)
+  ocv_check_flag_support(CXX "${option}" _varname ${ARGN})
+  if(${_varname})
+    set(OPENCV_EXTRA_CXX_FLAGS "${OPENCV_EXTRA_CXX_FLAGS} ${option}")
+  endif()
+
+  ocv_check_flag_support(C "${option}" _varname ${ARGN})
+  if(${_varname})
+    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} ${option}")
+  endif()
+endmacro()
+
 if(MINGW)
  # http://gcc.gnu.org/bugzilla/show_bug.cgi?id=40838
  # here we are trying to workaround the problem
  include(CheckCXXCompilerFlag)
  CHECK_CXX_COMPILER_FLAG(-mstackrealign HAVE_STACKREALIGN_FLAG)
  if(HAVE_STACKREALIGN_FLAG)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -mstackrealign")
+    set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} -mstackrealign")
  else()
    CHECK_CXX_COMPILER_FLAG(-mpreferred-stack-boundary=2 HAVE_PREFERRED_STACKBOUNDARY_FLAG)
    if(HAVE_PREFERRED_STACKBOUNDARY_FLAG)
-      set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -mstackrealign")
+      set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} -mstackrealign")
    endif()
  endif()
 endif()

 if(CMAKE_COMPILER_IS_GNUCXX)
  # High level of warnings.
-  set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -Wall")
-
-  set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -Werror=return-type -Werror=non-virtual-dtor -Werror=address -Werror=sequence-point -Werror=format-security")
-  set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -Wmissing-declarations -Wcast-align -Wundef -Winit-self -Wpointer-arith") #-Wstrict-aliasing=2
+  add_extra_compiler_option(-Wall)
+  add_extra_compiler_option(-Werror=return-type)
+  add_extra_compiler_option(-Werror=non-virtual-dtor)
+  add_extra_compiler_option(-Werror=address)
+  add_extra_compiler_option(-Werror=sequence-point)
+  add_extra_compiler_option(-Wformat)
+  add_extra_compiler_option(-Werror=format-security -Wformat)
+  add_extra_compiler_option(-Wmissing-declarations)
+  add_extra_compiler_option(-Wmissing-prototypes)
+  add_extra_compiler_option(-Wstrict-prototypes)
+  add_extra_compiler_option(-Wundef)
+  add_extra_compiler_option(-Winit-self)
+  add_extra_compiler_option(-Wpointer-arith)
+  #add_extra_compiler_option(-Wcast-align)
+  #add_extra_compiler_option(-Wstrict-aliasing=2)
+  #add_extra_compiler_option(-Wshadow)

  # The -Wno-long-long is required in 64bit systems when including sytem headers.
  if(X86_64)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -Wno-long-long")
+    add_extra_compiler_option(-Wno-long-long)
  endif()

  # We need pthread's
  if(UNIX AND NOT ANDROID)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -pthread")
+    add_extra_compiler_option(-pthread)
  endif()

  if(OPENCV_WARNINGS_ARE_ERRORS)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -Werror")
+    add_extra_compiler_option(-Werror)
  endif()

  if(X86 AND NOT MINGW64 AND NOT X86_64 AND NOT APPLE)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -march=i686")
+    add_extra_compiler_option(-march=i686)
  endif()

  # Other optimizations
  if(ENABLE_OMIT_FRAME_POINTER)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -fomit-frame-pointer")
+    add_extra_compiler_option(-fomit-frame-pointer)
  else()
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -fno-omit-frame-pointer")
+    add_extra_compiler_option(-fno-omit-frame-pointer)
  endif()
  if(ENABLE_FAST_MATH)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -ffast-math")
+    add_extra_compiler_option(-ffast-math)
  endif()
  if(ENABLE_POWERPC)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -mcpu=G3 -mtune=G5")
+    add_extra_compiler_option("-mcpu=G3 -mtune=G5")
  endif()
  if(ENABLE_SSE)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -msse")
+    add_extra_compiler_option(-msse)
  endif()
  if(ENABLE_SSE2)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -msse2")
+    add_extra_compiler_option(-msse2)
  endif()

  # SSE3 and further should be disabled under MingW because it generates compiler errors
  if(NOT MINGW)
    if(ENABLE_SSE3)
-      set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -msse3")
+      add_extra_compiler_option(-msse3)
    endif()

    if(${CMAKE_OPENCV_GCC_VERSION_NUM} GREATER 402)
@@ -102,14 +128,14 @@ if(CMAKE_COMPILER_IS_GNUCXX)

    if(HAVE_GCC42_OR_NEWER OR APPLE)
      if(ENABLE_SSSE3)
-        set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -mssse3")
+        add_extra_compiler_option(-mssse3)
      endif()
      if(HAVE_GCC43_OR_NEWER)
        if(ENABLE_SSE41)
-           set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -msse4.1")
+           add_extra_compiler_option(-msse4.1)
        endif()
        if(ENABLE_SSE42)
-           set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -msse4.2")
+           add_extra_compiler_option(-msse4.2)
        endif()
      endif()
    endif()
@@ -117,39 +143,40 @@ if(CMAKE_COMPILER_IS_GNUCXX)

  if(X86 OR X86_64)
    if(NOT APPLE AND CMAKE_SIZEOF_VOID_P EQUAL 4)
-       if(ENABLE_SSE2)
-         set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -mfpmath=sse")# !! important - be on the same wave with x64 compilers
-       else()
-         set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -mfpmath=387")
-       endif()
+      if(ENABLE_SSE2)
+        add_extra_compiler_option(-mfpmath=sse)# !! important - be on the same wave with x64 compilers
+      else()
+        add_extra_compiler_option(-mfpmath=387)
+      endif()
    endif()
  endif()

  # Profiling?
  if(ENABLE_PROFILING)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -pg -g")
+    add_extra_compiler_option("-pg -g")
    # turn off incompatible options
-    foreach(flags CMAKE_CXX_FLAGS CMAKE_C_FLAGS CMAKE_CXX_FLAGS_RELEASE CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_DEBUG CMAKE_C_FLAGS_DEBUG OPENCV_EXTRA_C_FLAGS_RELEASE)
+    foreach(flags CMAKE_CXX_FLAGS CMAKE_C_FLAGS CMAKE_CXX_FLAGS_RELEASE CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_DEBUG CMAKE_C_FLAGS_DEBUG
+                  OPENCV_EXTRA_FLAGS_RELEASE OPENCV_EXTRA_FLAGS_DEBUG OPENCV_EXTRA_C_FLAGS OPENCV_EXTRA_CXX_FLAGS)
      string(REPLACE "-fomit-frame-pointer" "" ${flags} "${${flags}}")
      string(REPLACE "-ffunction-sections" "" ${flags} "${${flags}}")
    endforeach()
  elseif(NOT APPLE AND NOT ANDROID)
    # Remove unreferenced functions: function level linking
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -ffunction-sections")
+    add_extra_compiler_option(-ffunction-sections)
  endif()

-  set(OPENCV_EXTRA_C_FLAGS_RELEASE "${OPENCV_EXTRA_C_FLAGS_RELEASE} -DNDEBUG")
-  set(OPENCV_EXTRA_C_FLAGS_DEBUG "${OPENCV_EXTRA_C_FLAGS_DEBUG} -O0 -DDEBUG -D_DEBUG")
+  set(OPENCV_EXTRA_FLAGS_RELEASE "${OPENCV_EXTRA_FLAGS_RELEASE} -DNDEBUG")
+  set(OPENCV_EXTRA_FLAGS_DEBUG "${OPENCV_EXTRA_FLAGS_DEBUG} -O0 -DDEBUG -D_DEBUG")
  if(BUILD_WITH_DEBUG_INFO)
-    set(OPENCV_EXTRA_C_FLAGS_DEBUG "${OPENCV_EXTRA_C_FLAGS_DEBUG} -ggdb3")
+    set(OPENCV_EXTRA_FLAGS_DEBUG "${OPENCV_EXTRA_FLAGS_DEBUG} -ggdb3")
  endif()
 endif()

 if(MSVC)
-  set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} /D _CRT_SECURE_NO_DEPRECATE /D _CRT_NONSTDC_NO_DEPRECATE /D _SCL_SECURE_NO_WARNINGS")
+  set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /D _CRT_SECURE_NO_DEPRECATE /D _CRT_NONSTDC_NO_DEPRECATE /D _SCL_SECURE_NO_WARNINGS")
  # 64-bit portability warnings, in MSVC80
  if(MSVC80)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} /Wp64")
+    set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /Wp64")
  endif()

  if(BUILD_WITH_DEBUG_INFO)
@@ -157,38 +184,38 @@ if(MSVC)
  endif()

  # Remove unreferenced functions: function level linking
-  set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} /Gy")
+  set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /Gy")
  if(NOT MSVC_VERSION LESS 1400)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} /bigobj")
+    set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /bigobj")
  endif()
  if(BUILD_WITH_DEBUG_INFO)
-    set(OPENCV_EXTRA_C_FLAGS_RELEASE "${OPENCV_EXTRA_C_FLAGS_RELEASE} /Zi")
+    set(OPENCV_EXTRA_FLAGS_RELEASE "${OPENCV_EXTRA_FLAGS_RELEASE} /Zi")
  endif()

  if(NOT MSVC64)
    # 64-bit MSVC compiler uses SSE/SSE2 by default
    if(ENABLE_SSE)
-      set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} /arch:SSE")
+      set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /arch:SSE")
    endif()
    if(ENABLE_SSE2)
-      set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} /arch:SSE2")
+      set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /arch:SSE2")
    endif()
  endif()

  if(ENABLE_SSE3)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} /arch:SSE3")
+    set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /arch:SSE3")
  endif()
  if(ENABLE_SSE4_1)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} /arch:SSE4.1")
+    set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /arch:SSE4.1")
  endif()

  if(ENABLE_SSE OR ENABLE_SSE2 OR ENABLE_SSE3 OR ENABLE_SSE4_1)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} /Oi")
+    set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /Oi")
  endif()

  if(X86 OR X86_64)
    if(CMAKE_SIZEOF_VOID_P EQUAL 4 AND ENABLE_SSE2)
-      set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} /fp:fast")# !! important - be on the same wave with x64 compilers
+      set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /fp:fast")# !! important - be on the same wave with x64 compilers
    endif()
  endif()
 endif()
@@ -197,33 +224,31 @@ endif()
 if(NOT BUILD_SHARED_LIBS AND CMAKE_COMPILER_IS_GNUCXX AND NOT ANDROID)
  # Android does not need these settings because they are already set by toolchain file
  set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} stdc++)
-  set(OPENCV_EXTRA_C_FLAGS "-fPIC ${OPENCV_EXTRA_C_FLAGS}")
+  set(OPENCV_EXTRA_FLAGS "-fPIC ${OPENCV_EXTRA_FLAGS}")
 endif()

 # Add user supplied extra options (optimization, etc...)
 # ==========================================================
-set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS}" CACHE INTERNAL "Extra compiler options")
-set(OPENCV_EXTRA_C_FLAGS_RELEASE "${OPENCV_EXTRA_C_FLAGS_RELEASE}" CACHE INTERNAL "Extra compiler options for Release build")
-set(OPENCV_EXTRA_C_FLAGS_DEBUG "${OPENCV_EXTRA_C_FLAGS_DEBUG}" CACHE INTERNAL "Extra compiler options for Debug build")
+set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS}" CACHE INTERNAL "Extra compiler options")
+set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS}" CACHE INTERNAL "Extra compiler options for C sources")
+set(OPENCV_EXTRA_CXX_FLAGS "${OPENCV_EXTRA_CXX_FLAGS}" CACHE INTERNAL "Extra compiler options for C++ sources")
+set(OPENCV_EXTRA_FLAGS_RELEASE "${OPENCV_EXTRA_FLAGS_RELEASE}" CACHE INTERNAL "Extra compiler options for Release build")
+set(OPENCV_EXTRA_FLAGS_DEBUG "${OPENCV_EXTRA_FLAGS_DEBUG}" CACHE INTERNAL "Extra compiler options for Debug build")
 set(OPENCV_EXTRA_EXE_LINKER_FLAGS "${OPENCV_EXTRA_EXE_LINKER_FLAGS}" CACHE INTERNAL "Extra linker flags")
 set(OPENCV_EXTRA_EXE_LINKER_FLAGS_RELEASE "${OPENCV_EXTRA_EXE_LINKER_FLAGS_RELEASE}" CACHE INTERNAL "Extra linker flags for Release build")
 set(OPENCV_EXTRA_EXE_LINKER_FLAGS_DEBUG "${OPENCV_EXTRA_EXE_LINKER_FLAGS_DEBUG}" CACHE INTERNAL "Extra linker flags for Debug build")

 #combine all "extra" options
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OPENCV_EXTRA_C_FLAGS}")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OPENCV_EXTRA_C_FLAGS}")
-set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}  ${OPENCV_EXTRA_C_FLAGS_RELEASE}")
-set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${OPENCV_EXTRA_C_FLAGS_RELEASE}")
-set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${OPENCV_EXTRA_C_FLAGS_DEBUG}")
-set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${OPENCV_EXTRA_C_FLAGS_DEBUG}")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OPENCV_EXTRA_FLAGS} ${OPENCV_EXTRA_C_FLAGS}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OPENCV_EXTRA_FLAGS} ${OPENCV_EXTRA_CXX_FLAGS}")
+set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${OPENCV_EXTRA_FLAGS_RELEASE}")
+set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${OPENCV_EXTRA_FLAGS_RELEASE}")
+set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${OPENCV_EXTRA_FLAGS_DEBUG}")
+set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${OPENCV_EXTRA_FLAGS_DEBUG}")
 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OPENCV_EXTRA_EXE_LINKER_FLAGS}")
 set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} ${OPENCV_EXTRA_EXE_LINKER_FLAGS_RELEASE}")
 set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} ${OPENCV_EXTRA_EXE_LINKER_FLAGS_DEBUG}")

-if(CMAKE_COMPILER_IS_GNUCXX)
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wmissing-prototypes -Wstrict-prototypes")
-endif()
-
 if(MSVC)
  # avoid warnings from MSVC about overriding the /W* option
  # we replace /W3 with /W4 only for C++ files,

--- a/cmake/OpenCVGenHeaders.cmake
+++ b/cmake/OpenCVGenHeaders.cmake
@@ -20,17 +20,17 @@ set(OPENCV_MOD_LIST ${OPENCV_MODULES_PUBLIC})
 ocv_list_sort(OPENCV_MOD_LIST)
 foreach(m ${OPENCV_MOD_LIST})
  string(TOUPPER "${m}" m)
-  set(OPENCV_MODULE_DEFINITIONS_CONFIGMAKE "${OPENCV_MODULE_DEFINITIONS_CONFIGMAKE}#define HAVE_${m} 1\n")
+  set(OPENCV_MODULE_DEFINITIONS_CONFIGMAKE "${OPENCV_MODULE_DEFINITIONS_CONFIGMAKE}#define HAVE_${m}\n")
 endforeach()

 set(OPENCV_MODULE_DEFINITIONS_CONFIGMAKE "${OPENCV_MODULE_DEFINITIONS_CONFIGMAKE}\n")

-set(OPENCV_MOD_LIST ${OPENCV_MODULES_DISABLED_USER} ${OPENCV_MODULES_DISABLED_AUTO})
-ocv_list_sort(OPENCV_MOD_LIST)
-foreach(m ${OPENCV_MOD_LIST})
-  string(TOUPPER "${m}" m)
-  set(OPENCV_MODULE_DEFINITIONS_CONFIGMAKE "${OPENCV_MODULE_DEFINITIONS_CONFIGMAKE}#undef HAVE_${m}\n")
-endforeach()
+#set(OPENCV_MOD_LIST ${OPENCV_MODULES_DISABLED_USER} ${OPENCV_MODULES_DISABLED_AUTO} ${OPENCV_MODULES_DISABLED_FORCE})
+#ocv_list_sort(OPENCV_MOD_LIST)
+#foreach(m ${OPENCV_MOD_LIST})
+#  string(TOUPPER "${m}" m)
+#  set(OPENCV_MODULE_DEFINITIONS_CONFIGMAKE "${OPENCV_MODULE_DEFINITIONS_CONFIGMAKE}#undef HAVE_${m}\n")
+#endforeach()

 configure_file("${OpenCV_SOURCE_DIR}/cmake/templates/opencv_modules.hpp.in" "${OPENCV_CONFIG_FILE_INCLUDE_DIR}/opencv2/opencv_modules.hpp")
 install(FILES "${OPENCV_CONFIG_FILE_INCLUDE_DIR}/opencv2/opencv_modules.hpp" DESTINATION ${OPENCV_INCLUDE_PREFIX}/opencv2 COMPONENT main)
--- a/cmake/OpenCVUtils.cmake
+++ b/cmake/OpenCVUtils.cmake
@@ -47,12 +47,12 @@ macro(ocv_check_flag_support lang flag varname)

  string(TOUPPER "${flag}" ${varname})
  string(REGEX REPLACE "^(/|-)" "HAVE_${_lang}_" ${varname} "${${varname}}")
-  string(REPLACE "-" "_" ${varname} "${${varname}}")
+  string(REGEX REPLACE " -|-|=| |\\." "_" ${varname} "${${varname}}")

  if(_lang STREQUAL "CXX")
-    CHECK_CXX_COMPILER_FLAG(${flag} ${${varname}})
+    CHECK_CXX_COMPILER_FLAG("${ARGN} ${flag}" ${${varname}})
  elseif(_lang STREQUAL "C")
-    CHECK_C_COMPILER_FLAG("${flag}" ${${varname}})
+    CHECK_C_COMPILER_FLAG("${ARGN} ${flag}" ${${varname}})
  else()
    set(${varname} FALSE)
  endif()

--- a/modules/highgui/src/window.cpp
+++ b/modules/highgui/src/window.cpp
@@ -724,10 +724,10 @@ CV_IMPL void cvSaveWindowParameters(const char* name)
    CV_NO_GUI_ERROR("cvSaveWindowParameters");
 }

-CV_IMPL void cvLoadWindowParameterss(const char* name)
-{
-    CV_NO_GUI_ERROR("cvLoadWindowParameters");
-}
+// CV_IMPL void cvLoadWindowParameterss(const char* name)
+// {
+//     CV_NO_GUI_ERROR("cvLoadWindowParameters");
+// }

 CV_IMPL int cvCreateButton(const char*, void (*)(int, void*), void*, int, int)
 {

--- a/modules/highgui/test/test_gui.cpp
+++ b/modules/highgui/test/test_gui.cpp
@@ -43,7 +43,7 @@
 #include "test_precomp.hpp"
 #include "opencv2/highgui/highgui.hpp"

-#if defined HAVE_GTK  || defined HAVE_QT || defined WIN32 || defined _WIN32 || HAVE_CARBON || HAVE_COCOA
+#if defined HAVE_GTK  || defined HAVE_QT || defined WIN32 || defined _WIN32 || defined HAVE_CARBON || defined HAVE_COCOA

 using namespace cv;
 using namespace std;

--- a/modules/java/CMakeLists.txt
+++ b/modules/java/CMakeLists.txt
@@ -162,6 +162,8 @@ else()
 endif()
 add_dependencies(${the_module} ${api_target})

+ocv_warnings_disable(CMAKE_CXX_FLAGS -Wmissing-declarations)
+
 # Additional target properties
 set_target_properties(${the_module} PROPERTIES
    OUTPUT_NAME "${the_module}"

--- a/modules/java/src/cpp/jni_part.cpp
+++ b/modules/java/src/cpp/jni_part.cpp
 #include <jni.h>

+#include "opencv2/opencv_modules.hpp"
+
+#ifdef HAVE_OPENCV_NONFREE
+#  include "opencv2/nonfree/nonfree.hpp"
+#endif
+
+#ifdef HAVE_OPENCV_FEATURES2D
+#  include "opencv2/features2d/features2d.hpp"
+#endif
+
+#ifdef HAVE_OPENCV_VIDEO
+#  include "opencv2/video/video.hpp"
+#endif
+
+#ifdef HAVE_OPENCV_ML
+#  include "opencv2/ml/ml.hpp"
+#endif
+
 extern "C" {

 JNIEXPORT jint JNICALL
@@ -9,6 +27,23 @@ JNI_OnLoad(JavaVM* vm, void* reserved)
    if (vm->GetEnv((void**) &env, JNI_VERSION_1_6) != JNI_OK)
        return -1;

+    bool init = true;
+#ifdef HAVE_OPENCV_NONFREE
+    init &= cv::initModule_nonfree();
+#endif
+#ifdef HAVE_OPENCV_FEATURES2D
+    init &= cv::initModule_features2d();
+#endif
+#ifdef HAVE_OPENCV_VIDEO
+    init &= cv::initModule_video();
+#endif
+#ifdef HAVE_OPENCV_ML
+    init &= cv::initModule_ml();
+#endif
+
+    if(!init)
+        return -1;
+
    /* get class with (*env)->FindClass */
    /* register methods with (*env)->RegisterNatives */

@@ -21,16 +56,4 @@ JNI_OnUnload(JavaVM *vm, void *reserved)
  //do nothing
 }

-} // extern "C"
-
-#include "opencv2/opencv_modules.hpp"
-
-#if HAVE_OPENCV_MODULES_NONFREE
-#include "opencv2/nonfree/nonfree.hpp"
-static bool makeUseOfNonfree = initModule_nonfree();
-#endif
-
-#if HAVE_OPENCV_MODULES_FEATURES2D
-#include "opencv2/features2d/features2d.hpp"
-static bool makeUseOfNonfree = initModule_features2d();
-#endif
\ No newline at end of file
+} // extern "C"
\ No newline at end of file
--- a/modules/stitching/perf/perf_stich.cpp
+++ b/modules/stitching/perf/perf_stich.cpp
@@ -18,7 +18,7 @@ using std::tr1::get;
 typedef TestBaseWithParam<String> stitch;
 typedef TestBaseWithParam<String> match;

-#if HAVE_OPENCV_NONFREE
+#ifdef HAVE_OPENCV_NONFREE
 #define TEST_DETECTORS testing::Values("surf", "orb")
 #else
 #define TEST_DETECTORS testing::Values<String>("orb")

--- a/modules/stitching/src/stitcher.cpp
+++ b/modules/stitching/src/stitcher.cpp
@@ -61,7 +61,7 @@ Stitcher Stitcher::createDefault(bool try_use_gpu)
 #ifdef HAVE_OPENCV_GPU
    if (try_use_gpu && gpu::getCudaEnabledDeviceCount() > 0)
    {
-#if HAVE_OPENCV_NONFREE
+#ifdef HAVE_OPENCV_NONFREE
        stitcher.setFeaturesFinder(new detail::SurfFeaturesFinderGpu());
 #else
        stitcher.setFeaturesFinder(new detail::OrbFeaturesFinder());
@@ -72,7 +72,7 @@ Stitcher Stitcher::createDefault(bool try_use_gpu)
    else
 #endif
    {
-#if HAVE_OPENCV_NONFREE
+#ifdef HAVE_OPENCV_NONFREE
        stitcher.setFeaturesFinder(new detail::SurfFeaturesFinder());
 #else
        stitcher.setFeaturesFinder(new detail::OrbFeaturesFinder());

--- a/modules/stitching/test/test_matchers.cpp
+++ b/modules/stitching/test/test_matchers.cpp
@@ -42,7 +42,7 @@
 #include "test_precomp.hpp"
 #include "opencv2/opencv_modules.hpp"

-#if HAVE_OPENCV_NONFREE
+#ifdef HAVE_OPENCV_NONFREE

 using namespace cv;
 using namespace std;
@@ -57,7 +57,7 @@ TEST(SurfFeaturesFinder, CanFindInROIs)
    rois.push_back(Rect(img.cols / 2, img.rows / 2, img.cols - img.cols / 2, img.rows - img.rows / 2));
    detail::ImageFeatures roi_features;
    (*finder)(img, roi_features, rois);
-    
+
    int tl_rect_count = 0, br_rect_count = 0, bad_count = 0;
    for (size_t i = 0; i < roi_features.keypoints.size(); ++i)
    {

--- a/modules/videostab/include/opencv2/videostab/global_motion.hpp
+++ b/modules/videostab/include/opencv2/videostab/global_motion.hpp
@@ -53,7 +53,7 @@
 #include "opencv2/videostab/motion_core.hpp"
 #include "opencv2/videostab/outlier_rejection.hpp"

-#if HAVE_OPENCV_GPU
+#ifdef HAVE_OPENCV_GPU
  #include "opencv2/gpu/gpu.hpp"
 #endif

@@ -73,7 +73,7 @@ CV_EXPORTS Mat estimateGlobalMotionRobust(

 class CV_EXPORTS MotionEstimatorBase
 {
-public:    
+public:
    virtual ~MotionEstimatorBase() {}

    virtual void setMotionModel(MotionModel val) { motionModel_ = val; }
@@ -200,7 +200,7 @@ private:
    std::vector<Point2f> pointsPrevGood_, pointsGood_;
 };

-#if HAVE_OPENCV_GPU
+#ifdef HAVE_OPENCV_GPU
 class CV_EXPORTS KeypointBasedMotionEstimatorGpu : public ImageMotionEstimatorBase
 {
 public:

--- a/modules/videostab/include/opencv2/videostab/optical_flow.hpp
+++ b/modules/videostab/include/opencv2/videostab/optical_flow.hpp
@@ -46,7 +46,7 @@
 #include "opencv2/core/core.hpp"
 #include "opencv2/opencv_modules.hpp"

-#if HAVE_OPENCV_GPU
+#ifdef HAVE_OPENCV_GPU
  #include "opencv2/gpu/gpu.hpp"
 #endif

@@ -99,7 +99,7 @@ public:
            OutputArray status, OutputArray errors);
 };

-#if HAVE_OPENCV_GPU
+#ifdef HAVE_OPENCV_GPU
 class CV_EXPORTS SparsePyrLkOptFlowEstimatorGpu
        : public PyrLkOptFlowEstimatorBase, public ISparseOptFlowEstimator
 {

--- a/modules/videostab/include/opencv2/videostab/wobble_suppression.hpp
+++ b/modules/videostab/include/opencv2/videostab/wobble_suppression.hpp
@@ -48,7 +48,7 @@
 #include "opencv2/videostab/global_motion.hpp"
 #include "opencv2/videostab/log.hpp"

-#if HAVE_OPENCV_GPU
+#ifdef HAVE_OPENCV_GPU
  #include "opencv2/gpu/gpu.hpp"
 #endif

@@ -119,7 +119,7 @@ private:
    Mat_<float> mapx_, mapy_;
 };

-#if HAVE_OPENCV_GPU
+#ifdef HAVE_OPENCV_GPU
 class CV_EXPORTS MoreAccurateMotionWobbleSuppressorGpu : public MoreAccurateMotionWobbleSuppressorBase
 {
 public:

--- a/modules/videostab/src/global_motion.cpp
+++ b/modules/videostab/src/global_motion.cpp
@@ -621,7 +621,7 @@ Mat ToFileMotionWriter::estimate(const Mat &frame0, const Mat &frame1, bool *ok)

 KeypointBasedMotionEstimator::KeypointBasedMotionEstimator(Ptr<MotionEstimatorBase> estimator)
    : ImageMotionEstimatorBase(estimator->motionModel()), motionEstimator_(estimator)
-{    
+{
    setDetector(new GoodFeaturesToTrackDetector());
    setOpticalFlowEstimator(new SparsePyrLkOptFlowEstimator());
    setOutlierRejector(new NullOutlierRejector());
@@ -686,11 +686,11 @@ Mat KeypointBasedMotionEstimator::estimate(const Mat &frame0, const Mat &frame1,
 }


-#if HAVE_OPENCV_GPU
+#ifdef HAVE_OPENCV_GPU
 KeypointBasedMotionEstimatorGpu::KeypointBasedMotionEstimatorGpu(Ptr<MotionEstimatorBase> estimator)
    : ImageMotionEstimatorBase(estimator->motionModel()), motionEstimator_(estimator)
 {
-    CV_Assert(gpu::getCudaEnabledDeviceCount() > 0);    
+    CV_Assert(gpu::getCudaEnabledDeviceCount() > 0);
    setOutlierRejector(new NullOutlierRejector());
 }

@@ -720,7 +720,7 @@ Mat KeypointBasedMotionEstimatorGpu::estimate(const gpu::GpuMat &frame0, const g
    detector_(grayFrame0, pointsPrev_);

    // find correspondences
-    optFlowEstimator_.run(frame0, frame1, pointsPrev_, points_, status_);    
+    optFlowEstimator_.run(frame0, frame1, pointsPrev_, points_, status_);

    // leave good correspondences only
    gpu::compactPoints(pointsPrev_, points_, status_);

--- a/modules/videostab/src/inpainting.cpp
+++ b/modules/videostab/src/inpainting.cpp
@@ -241,7 +241,7 @@ public:
            for (int dx = -rad; dx <= rad; ++dx)
            {
                int qx0 = x + dx;
-                int qy0 = y + dy;               
+                int qy0 = y + dy;

                if (qy0 >= 0 && qy0 < mask0.rows && qx0 >= 0 && qx0 < mask0.cols && mask0(qy0,qx0))
                {
@@ -325,7 +325,7 @@ public:

 MotionInpainter::MotionInpainter()
 {
-#if HAVE_OPENCV_GPU
+#ifdef HAVE_OPENCV_GPU
    setOptFlowEstimator(new DensePyrLkOptFlowEstimatorGpu());
 #else
    CV_Error(CV_StsNotImplemented, "Current implementation of MotionInpainter requires GPU");
@@ -374,7 +374,7 @@ void MotionInpainter::inpaint(int idx, Mat &frame, Mat &mask)

        // warp frame

-        frame1_ = at(neighbor, *frames_);        
+        frame1_ = at(neighbor, *frames_);

        if (motionModel_ != MM_HOMOGRAPHY)
            warpAffine(
@@ -532,7 +532,7 @@ void completeFrameAccordingToFlow(

                if (x1 >= 0 && x1 < frame1.cols && y1 >= 0 && y1 < frame1.rows && mask1_(y1,x1)
                    && sqr(flowX_(y0,x0)) + sqr(flowY_(y0,x0)) < sqr(distThresh))
-                {                    
+                {
                    frame0.at<Point3_<uchar> >(y0,x0) = frame1.at<Point3_<uchar> >(y1,x1);
                    mask0_(y0,x0) = 255;
                }

--- a/modules/videostab/src/optical_flow.cpp
+++ b/modules/videostab/src/optical_flow.cpp
@@ -60,7 +60,7 @@ void SparsePyrLkOptFlowEstimator::run(
 }


-#if HAVE_OPENCV_GPU
+#ifdef HAVE_OPENCV_GPU
 SparsePyrLkOptFlowEstimatorGpu::SparsePyrLkOptFlowEstimatorGpu()
 {
    CV_Assert(gpu::getCudaEnabledDeviceCount() > 0);
@@ -135,7 +135,7 @@ void DensePyrLkOptFlowEstimatorGpu::run(
    flowX_.download(flowX.getMatRef());
    flowY_.download(flowY.getMatRef());
 }
-#endif // #if HAVE_OPENCV_GPU
+#endif // HAVE_OPENCV_GPU

 } // namespace videostab
 } // namespace cv
--- a/modules/videostab/src/wobble_suppression.cpp
+++ b/modules/videostab/src/wobble_suppression.cpp
@@ -115,7 +115,7 @@ void MoreAccurateMotionWobbleSuppressor::suppress(int idx, const Mat &frame, Mat
 }


-#if HAVE_OPENCV_GPU
+#ifdef HAVE_OPENCV_GPU
 void MoreAccurateMotionWobbleSuppressorGpu::suppress(int idx, const gpu::GpuMat &frame, gpu::GpuMat &result)
 {
    CV_Assert(motions_ && stabilizationMotions_);

--- a/samples/android/CMakeLists.txt
+++ b/samples/android/CMakeLists.txt
@@ -4,6 +4,8 @@
 # ----------------------------------------------------------------------------
 add_custom_target(opencv_android_examples)

+ocv_warnings_disable(CMAKE_CXX_FLAGS -Wmissing-declarations)
+
 add_subdirectory(15-puzzle)
 add_subdirectory(face-detection)
 add_subdirectory(image-manipulations)

--- a/samples/cpp/videostab.cpp
+++ b/samples/cpp/videostab.cpp
@@ -215,7 +215,7 @@ public:
            outlierRejector = tblor;
        }

-#if HAVE_OPENCV_GPU
+#ifdef HAVE_OPENCV_GPU
        if (gpu)
        {
            KeypointBasedMotionEstimatorGpu *kbest = new KeypointBasedMotionEstimatorGpu(est);
@@ -256,7 +256,7 @@ public:
            outlierRejector = tblor;
        }

-#if HAVE_OPENCV_GPU
+#ifdef HAVE_OPENCV_GPU
        if (gpu)
        {
            KeypointBasedMotionEstimatorGpu *kbest = new KeypointBasedMotionEstimatorGpu(est);
@@ -341,7 +341,7 @@ int main(int argc, const char **argv)
            return 0;
        }

-#if HAVE_OPENCV_GPU
+#ifdef HAVE_OPENCV_GPU
        if (arg("gpu") == "yes")
        {
            cout << "initializing GPU..."; cout.flush();
@@ -419,7 +419,7 @@ int main(int argc, const char **argv)
            {
                MoreAccurateMotionWobbleSuppressorBase *ws = new MoreAccurateMotionWobbleSuppressor();
                if (arg("gpu") == "yes")
-#if HAVE_OPENCV_GPU
+#ifdef HAVE_OPENCV_GPU
                    ws = new MoreAccurateMotionWobbleSuppressorGpu();
 #else
                    throw runtime_error("OpenCV is built without GPU support");