diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4af166dded89..a7defe21e62a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -798,6 +798,25 @@ endif()
 # Finalization: generate configuration-based files
 # ----------------------------------------------------------------------------
 
+# generate export definintions file
+include(GenerateExportHeader)
+set(EXPORT_FILE_NAME "${OPENCV_CONFIG_FILE_INCLUDE_DIR}/opencv2/cv_exports.h")
+set(EXPORT_TARGET_NAME opencv_core)
+if(BUILD_opencv_world)
+  set(EXPORT_TARGET_NAME opencv_world)
+endif()
+generate_export_header(${EXPORT_TARGET_NAME}
+    BASE_NAME "CV"
+    EXPORT_FILE_NAME "${EXPORT_FILE_NAME}"
+    EXPORT_MACRO_NAME "CV_EXPORTS"
+    DEPRECATED_MACRO_NAME "CV_DEPRECATED"
+    NO_EXPORT_MACRO_NAME "CV_NO_EXPORTS"
+    NO_DEPRECATED_MACRO_NAME "CV_NO_DEPRECATED"
+    STATIC_DEFINE "CV_USE_STATIC"
+)
+install(FILES "${EXPORT_FILE_NAME}" DESTINATION "${OPENCV_INCLUDE_INSTALL_PATH}/opencv2" COMPONENT dev)
+
+
 # Generate platform-dependent and configuration-dependent headers
 include(cmake/OpenCVGenHeaders.cmake)
 
diff --git a/apps/traincascade/old_ml.hpp b/apps/traincascade/old_ml.hpp
index 1fe8b1ae5217..371fb5bf97b3 100644
--- a/apps/traincascade/old_ml.hpp
+++ b/apps/traincascade/old_ml.hpp
@@ -1895,32 +1895,6 @@ class CvANN_MLP : public CvStatModel
     cv::RNG* rng;
 };
 
-/****************************************************************************************\
-*                           Auxilary functions declarations                              *
-\****************************************************************************************/
-
-/* Generates <sample> from multivariate normal distribution, where <mean> - is an
-   average row vector, <cov> - symmetric covariation matrix */
-CVAPI(void) cvRandMVNormal( CvMat* mean, CvMat* cov, CvMat* sample,
-                           CvRNG* rng CV_DEFAULT(0) );
-
-/* Generates sample from gaussian mixture distribution */
-CVAPI(void) cvRandGaussMixture( CvMat* means[],
-                               CvMat* covs[],
-                               float weights[],
-                               int clsnum,
-                               CvMat* sample,
-                               CvMat* sampClasses CV_DEFAULT(0) );
-
-#define CV_TS_CONCENTRIC_SPHERES 0
-
-/* creates test set */
-CVAPI(void) cvCreateTestSet( int type, CvMat** samples,
-                 int num_samples,
-                 int num_features,
-                 CvMat** responses,
-                 int num_classes, ... );
-
 /****************************************************************************************\
 *                                      Data                                             *
 \****************************************************************************************/
diff --git a/apps/traincascade/old_ml_inner_functions.cpp b/apps/traincascade/old_ml_inner_functions.cpp
index 68e78b1e5700..5858a4014a90 100644
--- a/apps/traincascade/old_ml_inner_functions.cpp
+++ b/apps/traincascade/old_ml_inner_functions.cpp
@@ -114,153 +114,11 @@ void CvStatModel::write( CvFileStorage*, const char* ) const
     OPENCV_ERROR( CV_StsNotImplemented, "CvStatModel::write", "" );
 }
 
-
 void CvStatModel::read( CvFileStorage*, CvFileNode* )
 {
     OPENCV_ERROR( CV_StsNotImplemented, "CvStatModel::read", "" );
 }
 
-
-/* Calculates upper triangular matrix S, where A is a symmetrical matrix A=S'*S */
-static void cvChol( CvMat* A, CvMat* S )
-{
-    int dim = A->rows;
-
-    int i, j, k;
-    float sum;
-
-    for( i = 0; i < dim; i++ )
-    {
-        for( j = 0; j < i; j++ )
-            CV_MAT_ELEM(*S, float, i, j) = 0;
-
-        sum = 0;
-        for( k = 0; k < i; k++ )
-            sum += CV_MAT_ELEM(*S, float, k, i) * CV_MAT_ELEM(*S, float, k, i);
-
-        CV_MAT_ELEM(*S, float, i, i) = (float)sqrt(CV_MAT_ELEM(*A, float, i, i) - sum);
-
-        for( j = i + 1; j < dim; j++ )
-        {
-            sum = 0;
-            for( k = 0; k < i; k++ )
-                sum += CV_MAT_ELEM(*S, float, k, i) * CV_MAT_ELEM(*S, float, k, j);
-
-            CV_MAT_ELEM(*S, float, i, j) =
-                (CV_MAT_ELEM(*A, float, i, j) - sum) / CV_MAT_ELEM(*S, float, i, i);
-
-        }
-    }
-}
-
-/* Generates <sample> from multivariate normal distribution, where <mean> - is an
-   average row vector, <cov> - symmetric covariation matrix */
-CV_IMPL void cvRandMVNormal( CvMat* mean, CvMat* cov, CvMat* sample, CvRNG* rng )
-{
-    int dim = sample->cols;
-    int amount = sample->rows;
-
-    CvRNG state = rng ? *rng : cvRNG( cvGetTickCount() );
-    cvRandArr(&state, sample, CV_RAND_NORMAL, cvScalarAll(0), cvScalarAll(1) );
-
-    CvMat* utmat = cvCreateMat(dim, dim, sample->type);
-    CvMat* vect = cvCreateMatHeader(1, dim, sample->type);
-
-    cvChol(cov, utmat);
-
-    int i;
-    for( i = 0; i < amount; i++ )
-    {
-        cvGetRow(sample, vect, i);
-        cvMatMulAdd(vect, utmat, mean, vect);
-    }
-
-    cvReleaseMat(&vect);
-    cvReleaseMat(&utmat);
-}
-
-
-/* Generates <sample> of <amount> points from a discrete variate xi,
-   where Pr{xi = k} == probs[k], 0 < k < len - 1. */
-static void cvRandSeries( float probs[], int len, int sample[], int amount )
-{
-    CvMat* univals = cvCreateMat(1, amount, CV_32FC1);
-    float* knots = (float*)cvAlloc( len * sizeof(float) );
-
-    int i, j;
-
-    CvRNG state = cvRNG(-1);
-    cvRandArr(&state, univals, CV_RAND_UNI, cvScalarAll(0), cvScalarAll(1) );
-
-    knots[0] = probs[0];
-    for( i = 1; i < len; i++ )
-        knots[i] = knots[i - 1] + probs[i];
-
-    for( i = 0; i < amount; i++ )
-        for( j = 0; j < len; j++ )
-        {
-            if ( CV_MAT_ELEM(*univals, float, 0, i) <= knots[j] )
-            {
-                sample[i] = j;
-                break;
-            }
-        }
-
-    cvFree(&knots);
-}
-
-/* Generates <sample> from gaussian mixture distribution */
-CV_IMPL void cvRandGaussMixture( CvMat* means[],
-                                 CvMat* covs[],
-                                 float weights[],
-                                 int clsnum,
-                                 CvMat* sample,
-                                 CvMat* sampClasses )
-{
-    int dim = sample->cols;
-    int amount = sample->rows;
-
-    int i, clss;
-
-    int* sample_clsnum = (int*)cvAlloc( amount * sizeof(int) );
-    CvMat** utmats = (CvMat**)cvAlloc( clsnum * sizeof(CvMat*) );
-    CvMat* vect = cvCreateMatHeader(1, dim, CV_32FC1);
-
-    CvMat* classes;
-    if( sampClasses )
-        classes = sampClasses;
-    else
-        classes = cvCreateMat(1, amount, CV_32FC1);
-
-    CvRNG state = cvRNG(-1);
-    cvRandArr(&state, sample, CV_RAND_NORMAL, cvScalarAll(0), cvScalarAll(1));
-
-    cvRandSeries(weights, clsnum, sample_clsnum, amount);
-
-    for( i = 0; i < clsnum; i++ )
-    {
-        utmats[i] = cvCreateMat(dim, dim, CV_32FC1);
-        cvChol(covs[i], utmats[i]);
-    }
-
-    for( i = 0; i < amount; i++ )
-    {
-        CV_MAT_ELEM(*classes, float, 0, i) = (float)sample_clsnum[i];
-        cvGetRow(sample, vect, i);
-        clss = sample_clsnum[i];
-        cvMatMulAdd(vect, utmats[clss], means[clss], vect);
-    }
-
-    if( !sampClasses )
-        cvReleaseMat(&classes);
-    for( i = 0; i < clsnum; i++ )
-        cvReleaseMat(&utmats[i]);
-    cvFree(&utmats);
-    cvFree(&sample_clsnum);
-    cvReleaseMat(&vect);
-}
-
-
 CvMat* icvGenerateRandomClusterCenters ( int seed, const CvMat* data,
                                          int num_of_clusters, CvMat* _centers )
 {
@@ -317,55 +175,6 @@ CvMat* icvGenerateRandomClusterCenters ( int seed, const CvMat* data,
     return _centers ? _centers : centers;
 } // end of icvGenerateRandomClusterCenters
 
-// By S. Dilman - begin -
-
-#define ICV_RAND_MAX    4294967296 // == 2^32
-
-// static void cvRandRoundUni (CvMat* center,
-//                              float radius_small,
-//                              float radius_large,
-//                              CvMat* desired_matrix,
-//                              CvRNG* rng_state_ptr)
-// {
-//     float rad, norm, coefficient;
-//     int dim, size, i, j;
-//     CvMat *cov, sample;
-//     CvRNG rng_local;
-
-//     CV_FUNCNAME("cvRandRoundUni");
-//     __BEGIN__
-
-//     rng_local = *rng_state_ptr;
-
-//     CV_ASSERT ((radius_small >= 0) &&
-//                (radius_large > 0) &&
-//                (radius_small <= radius_large));
-//     CV_ASSERT (center && desired_matrix && rng_state_ptr);
-//     CV_ASSERT (center->rows == 1);
-//     CV_ASSERT (center->cols == desired_matrix->cols);
-
-//     dim = desired_matrix->cols;
-//     size = desired_matrix->rows;
-//     cov = cvCreateMat (dim, dim, CV_32FC1);
-//     cvSetIdentity (cov);
-//     cvRandMVNormal (center, cov, desired_matrix, &rng_local);
-
-//     for (i = 0; i < size; i++)
-//     {
-//         rad = (float)(cvRandReal(&rng_local)*(radius_large - radius_small) + radius_small);
-//         cvGetRow (desired_matrix, &sample, i);
-//         norm = (float) cvNorm (&sample, 0, CV_L2);
-//         coefficient = rad / norm;
-//         for (j = 0; j < dim; j++)
-//              CV_MAT_ELEM (sample, float, 0, j) *= coefficient;
-//     }
-
-//     __END__
-
-// }
-
-// By S. Dilman - end -
-
 static int CV_CDECL
 icvCmpIntegers( const void* a, const void* b )
 {
diff --git a/apps/traincascade/old_ml_tree.cpp b/apps/traincascade/old_ml_tree.cpp
index d7c6511cfdd7..832330d24fbd 100644
--- a/apps/traincascade/old_ml_tree.cpp
+++ b/apps/traincascade/old_ml_tree.cpp
@@ -1880,7 +1880,7 @@ double CvDTree::calc_node_dir( CvDTreeNode* node )
 namespace cv
 {
 
-template<> CV_EXPORTS void DefaultDeleter<CvDTreeSplit>::operator ()(CvDTreeSplit* obj) const
+template<> void DefaultDeleter<CvDTreeSplit>::operator ()(CvDTreeSplit* obj) const
 {
     fastFree(obj);
 }
diff --git a/cmake/OpenCVCompilerOptions.cmake b/cmake/OpenCVCompilerOptions.cmake
index f45ebdd84b0a..c03551b8d06f 100644
--- a/cmake/OpenCVCompilerOptions.cmake
+++ b/cmake/OpenCVCompilerOptions.cmake
@@ -33,8 +33,7 @@ if(MSVC)
   string(STRIP "${CMAKE_CXX_FLAGS_INIT}" CMAKE_CXX_FLAGS_INIT)
   if(CMAKE_CXX_FLAGS STREQUAL CMAKE_CXX_FLAGS_INIT)
     # override cmake default exception handling option
-    string(REPLACE "/EHsc" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHa")
+    string(REPLACE "/EHsc" "/EHa" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}"  CACHE STRING "Flags used by the compiler during all build types." FORCE)
   endif()
 endif()
@@ -178,10 +177,12 @@ if(CMAKE_COMPILER_IS_GNUCXX)
                   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}}")
+      string(REPLACE "-fdata-sections" "" ${flags} "${${flags}}")
     endforeach()
   elseif(NOT ((IOS OR ANDROID) AND NOT BUILD_SHARED_LIBS))
     # Remove unreferenced functions: function level linking
     add_extra_compiler_option(-ffunction-sections)
+    add_extra_compiler_option(-fdata-sections)
   endif()
 
   if(ENABLE_COVERAGE)
@@ -241,15 +242,6 @@ if(WINRT_PHONE AND WINRT_8_0)
   set(OPENCV_EXTRA_CXX_FLAGS "${OPENCV_EXTRA_CXX_FLAGS} /AI\$(WindowsSDK_MetadataPath)")
 endif()
 
-# Extra link libs if the user selects building static libs:
-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
-  if(NOT MINGW)
-    set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} stdc++)
-  endif()
-  set(OPENCV_EXTRA_FLAGS "-fPIC ${OPENCV_EXTRA_FLAGS}")
-endif()
-
 include(cmake/OpenCVCompilerOptimizations.cmake)
 
 if(COMMAND ocv_compiler_optimization_options)
diff --git a/cmake/OpenCVModule.cmake b/cmake/OpenCVModule.cmake
index defbf1fdd2eb..bf967502d780 100644
--- a/cmake/OpenCVModule.cmake
+++ b/cmake/OpenCVModule.cmake
@@ -852,7 +852,6 @@ macro(_ocv_create_module)
     ${${the_module}_pch}
     ${_VS_VERSION_FILE}
   )
-
   set_target_properties(${the_module} PROPERTIES LABELS "${OPENCV_MODULE_${the_module}_LABEL};Module")
   set_source_files_properties(${OPENCV_MODULE_${the_module}_HEADERS} ${OPENCV_MODULE_${the_module}_SOURCES} ${${the_module}_pch}
     PROPERTIES LABELS "${OPENCV_MODULE_${the_module}_LABEL};Module")
@@ -879,6 +878,8 @@ macro(_ocv_create_module)
     COMPILE_PDB_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
     LIBRARY_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
     RUNTIME_OUTPUT_DIRECTORY ${EXECUTABLE_OUTPUT_PATH}
+    DEFINE_SYMBOL CVAPI_EXPORTS
+    POSITION_INDEPENDENT_CODE TRUE
   )
 
   # For dynamic link numbering convenions
@@ -891,11 +892,6 @@ macro(_ocv_create_module)
     )
   endif()
 
-  if((NOT DEFINED OPENCV_MODULE_TYPE AND BUILD_SHARED_LIBS)
-      OR (DEFINED OPENCV_MODULE_TYPE AND OPENCV_MODULE_TYPE STREQUAL SHARED))
-    set_target_properties(${the_module} PROPERTIES DEFINE_SYMBOL CVAPI_EXPORTS)
-  endif()
-
   if (ENABLE_GNU_STL_DEBUG)
     target_compile_definitions(${the_module} PUBLIC _GLIBCXX_DEBUG)
   endif()
@@ -925,7 +921,7 @@ macro(_ocv_create_module)
   if(OPENCV_MODULE_${the_module}_HEADERS AND ";${OPENCV_MODULES_PUBLIC};" MATCHES ";${the_module};")
     foreach(hdr ${OPENCV_MODULE_${the_module}_HEADERS})
       string(REGEX REPLACE "^.*opencv2/" "opencv2/" hdr2 "${hdr}")
-      if(NOT hdr2 MATCHES "private" AND hdr2 MATCHES "^(opencv2/?.*)/[^/]+.h(..)?$" )
+      if(NOT hdr2 MATCHES "opencv2/${the_module}/private.*" AND hdr2 MATCHES "^(opencv2/?.*)/[^/]+.h(..)?$" )
         install(FILES ${hdr} OPTIONAL DESTINATION "${OPENCV_INCLUDE_INSTALL_PATH}/${CMAKE_MATCH_1}" COMPONENT dev)
       endif()
     endforeach()
diff --git a/modules/core/include/opencv2/core/cvdef.h b/modules/core/include/opencv2/core/cvdef.h
index b513b44c15f7..8b2fe792afa2 100644
--- a/modules/core/include/opencv2/core/cvdef.h
+++ b/modules/core/include/opencv2/core/cvdef.h
@@ -248,22 +248,18 @@ Cv64suf;
 #  define DISABLE_OPENCV_24_COMPATIBILITY
 #endif
 
-#if (defined _WIN32 || defined WINCE || defined __CYGWIN__) && defined CVAPI_EXPORTS
-#  define CV_EXPORTS __declspec(dllexport)
-#elif defined __GNUC__ && __GNUC__ >= 4
-#  define CV_EXPORTS __attribute__ ((visibility ("default")))
-#else
-#  define CV_EXPORTS
+#include "opencv2/cv_exports.h"
+
+// fix for Android FAT_JAVA_LIB: symbols should have default visibility even in static libraries
+#ifdef __ANDROID__
+#undef CV_EXPORTS
+#define CV_EXPORTS __attribute__ ((visibility ("default")))
 #endif
 
-#ifndef CV_DEPRECATED
-#  if defined(__GNUC__)
-#    define CV_DEPRECATED __attribute__ ((deprecated))
-#  elif defined(_MSC_VER)
-#    define CV_DEPRECATED __declspec(deprecated)
-#  else
-#    define CV_DEPRECATED
-#  endif
+#ifdef _MSC_VER
+#define CV_EXPORTS_TEMPLATE
+#else
+#define CV_EXPORTS_TEMPLATE CV_EXPORTS
 #endif
 
 #ifndef CV_EXTERN_C
diff --git a/modules/core/test/test_precomp.hpp b/modules/core/test/test_precomp.hpp
index 962348b04fed..015ecb73addc 100644
--- a/modules/core/test/test_precomp.hpp
+++ b/modules/core/test/test_precomp.hpp
@@ -11,6 +11,7 @@
 
 #include <iostream>
 #include "opencv2/ts.hpp"
+#include "opencv2/ts/ocl_test.hpp"
 #include "opencv2/core/core_c.h"
 
 #include "opencv2/core/cvdef.h"
diff --git a/modules/features2d/include/opencv2/features2d.hpp b/modules/features2d/include/opencv2/features2d.hpp
index 119782bf1ee4..82d76c40a3ca 100644
--- a/modules/features2d/include/opencv2/features2d.hpp
+++ b/modules/features2d/include/opencv2/features2d.hpp
@@ -786,7 +786,7 @@ struct CV_EXPORTS SL2
  * Euclidean distance functor
  */
 template<class T>
-struct CV_EXPORTS L2
+struct L2
 {
     enum { normType = NORM_L2 };
     typedef T ValueType;
@@ -802,7 +802,7 @@ struct CV_EXPORTS L2
  * Manhattan distance (city block distance) functor
  */
 template<class T>
-struct CV_EXPORTS L1
+struct L1
 {
     enum { normType = NORM_L1 };
     typedef T ValueType;
diff --git a/modules/flann/include/opencv2/flann/dummy.h b/modules/flann/include/opencv2/flann/dummy.h
index 8b1fa6309167..d6837e53c8be 100644
--- a/modules/flann/include/opencv2/flann/dummy.h
+++ b/modules/flann/include/opencv2/flann/dummy.h
@@ -5,10 +5,7 @@
 namespace cvflann
 {
 
-#if (defined _WIN32 || defined WINCE) && defined CVAPI_EXPORTS
-__declspec(dllexport)
-#endif
-void dummyfunc();
+CV_DEPRECATED inline void dummyfunc() {}
 
 }
 
diff --git a/modules/flann/src/flann.cpp b/modules/flann/src/flann.cpp
index 7ebb7eda7a83..388418f8894e 100644
--- a/modules/flann/src/flann.cpp
+++ b/modules/flann/src/flann.cpp
@@ -53,5 +53,4 @@ namespace cvflann
         flann_distance_type_ = distance_type;
     }
 
-    void dummyfunc() {}
 }
diff --git a/modules/flann/src/precomp.hpp b/modules/flann/src/precomp.hpp
index bcd8889d585d..099a6abce1fc 100644
--- a/modules/flann/src/precomp.hpp
+++ b/modules/flann/src/precomp.hpp
@@ -14,7 +14,6 @@
 #include "opencv2/flann/params.h"
 #include "opencv2/flann/saving.h"
 #include "opencv2/flann/general.h"
-#include "opencv2/flann/dummy.h"
 
 // index types
 #include "opencv2/flann/all_indices.h"
diff --git a/modules/java/CMakeLists.txt b/modules/java/CMakeLists.txt
index 71e249975849..d44b19523830 100644
--- a/modules/java/CMakeLists.txt
+++ b/modules/java/CMakeLists.txt
@@ -421,8 +421,8 @@ endif()
 
 
 ocv_add_library(${the_module} SHARED ${handwritten_h_sources} ${handwritten_cpp_sources} ${generated_cpp_sources}
-                                 ${copied_files}
-                                "${JAR_FILE}" "${JAR_FILE}.dephelper")
+                                ${copied_files}
+                               "${JAR_FILE}" "${JAR_FILE}.dephelper")
 
 if(BUILD_FAT_JAVA_LIB)
   set(__deps ${OPENCV_MODULE_${the_module}_DEPS} ${OPENCV_MODULES_BUILD})
@@ -456,6 +456,7 @@ set_target_properties(${the_module} PROPERTIES
     ARCHIVE_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
     LIBRARY_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
     RUNTIME_OUTPUT_DIRECTORY ${EXECUTABLE_OUTPUT_PATH}
+    DEFINE_SYMBOL CVAPI_EXPORTS
     )
 
 if(ANDROID)
diff --git a/modules/stitching/include/opencv2/stitching/detail/warpers.hpp b/modules/stitching/include/opencv2/stitching/detail/warpers.hpp
index cfaf225fa3bf..ddb2fb51c094 100644
--- a/modules/stitching/include/opencv2/stitching/detail/warpers.hpp
+++ b/modules/stitching/include/opencv2/stitching/detail/warpers.hpp
@@ -138,7 +138,7 @@ struct CV_EXPORTS ProjectorBase
 /** @brief Base class for rotation-based warper using a detail::ProjectorBase_ derived class.
  */
 template <class P>
-class CV_EXPORTS RotationWarperBase : public RotationWarper
+class CV_EXPORTS_TEMPLATE RotationWarperBase : public RotationWarper
 {
 public:
     Point2f warpPoint(const Point2f &pt, InputArray K, InputArray R);
@@ -550,7 +550,7 @@ class CV_EXPORTS CylindricalWarperGpu : public CylindricalWarper
 };
 
 
-struct SphericalPortraitProjector : ProjectorBase
+struct CV_EXPORTS SphericalPortraitProjector : ProjectorBase
 {
     void mapForward(float x, float y, float &u, float &v);
     void mapBackward(float u, float v, float &x, float &y);
@@ -568,7 +568,7 @@ class CV_EXPORTS SphericalPortraitWarper : public RotationWarperBase<SphericalPo
     void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br);
 };
 
-struct CylindricalPortraitProjector : ProjectorBase
+struct CV_EXPORTS CylindricalPortraitProjector : ProjectorBase
 {
     void mapForward(float x, float y, float &u, float &v);
     void mapBackward(float u, float v, float &x, float &y);
@@ -587,7 +587,7 @@ class CV_EXPORTS CylindricalPortraitWarper : public RotationWarperBase<Cylindric
     }
 };
 
-struct PlanePortraitProjector : ProjectorBase
+struct CV_EXPORTS PlanePortraitProjector : ProjectorBase
 {
     void mapForward(float x, float y, float &u, float &v);
     void mapBackward(float u, float v, float &x, float &y);
diff --git a/modules/ts/include/opencv2/ts.hpp b/modules/ts/include/opencv2/ts.hpp
index d630a5a384e1..dd1bc1442582 100644
--- a/modules/ts/include/opencv2/ts.hpp
+++ b/modules/ts/include/opencv2/ts.hpp
@@ -86,11 +86,11 @@ class SkipTestException: public cv::Exception
     SkipTestException(const cv::String& message) : dummy(0) { this->msg = message; }
 };
 
-class CV_EXPORTS TS;
+class TS;
 
-CV_EXPORTS int64 readSeed(const char* str);
+int64 readSeed(const char* str);
 
-CV_EXPORTS void randUni( RNG& rng, Mat& a, const Scalar& param1, const Scalar& param2 );
+void randUni( RNG& rng, Mat& a, const Scalar& param1, const Scalar& param2 );
 
 inline unsigned randInt( RNG& rng )
 {
@@ -103,10 +103,10 @@ inline  double randReal( RNG& rng )
 }
 
 
-CV_EXPORTS const char* getTypeName( int type );
-CV_EXPORTS int typeByName( const char* type_name );
+const char* getTypeName( int type );
+int typeByName( const char* type_name );
 
-CV_EXPORTS string vec2str(const string& sep, const int* v, size_t nelems);
+string vec2str(const string& sep, const int* v, size_t nelems);
 
 inline int clipInt( int val, int min_val, int max_val )
 {
@@ -117,99 +117,99 @@ inline int clipInt( int val, int min_val, int max_val )
     return val;
 }
 
-CV_EXPORTS double getMinVal(int depth);
-CV_EXPORTS double getMaxVal(int depth);
+double getMinVal(int depth);
+double getMaxVal(int depth);
 
-CV_EXPORTS Size randomSize(RNG& rng, double maxSizeLog);
-CV_EXPORTS void randomSize(RNG& rng, int minDims, int maxDims, double maxSizeLog, vector<int>& sz);
-CV_EXPORTS int randomType(RNG& rng, int typeMask, int minChannels, int maxChannels);
-CV_EXPORTS Mat randomMat(RNG& rng, Size size, int type, double minVal, double maxVal, bool useRoi);
-CV_EXPORTS Mat randomMat(RNG& rng, const vector<int>& size, int type, double minVal, double maxVal, bool useRoi);
-CV_EXPORTS void add(const Mat& a, double alpha, const Mat& b, double beta,
+Size randomSize(RNG& rng, double maxSizeLog);
+void randomSize(RNG& rng, int minDims, int maxDims, double maxSizeLog, vector<int>& sz);
+int randomType(RNG& rng, int typeMask, int minChannels, int maxChannels);
+Mat randomMat(RNG& rng, Size size, int type, double minVal, double maxVal, bool useRoi);
+Mat randomMat(RNG& rng, const vector<int>& size, int type, double minVal, double maxVal, bool useRoi);
+void add(const Mat& a, double alpha, const Mat& b, double beta,
                       Scalar gamma, Mat& c, int ctype, bool calcAbs=false);
-CV_EXPORTS void multiply(const Mat& a, const Mat& b, Mat& c, double alpha=1);
-CV_EXPORTS void divide(const Mat& a, const Mat& b, Mat& c, double alpha=1);
+void multiply(const Mat& a, const Mat& b, Mat& c, double alpha=1);
+void divide(const Mat& a, const Mat& b, Mat& c, double alpha=1);
 
-CV_EXPORTS void convert(const Mat& src, cv::OutputArray dst, int dtype, double alpha=1, double beta=0);
-CV_EXPORTS void copy(const Mat& src, Mat& dst, const Mat& mask=Mat(), bool invertMask=false);
-CV_EXPORTS void set(Mat& dst, const Scalar& gamma, const Mat& mask=Mat());
+void convert(const Mat& src, cv::OutputArray dst, int dtype, double alpha=1, double beta=0);
+void copy(const Mat& src, Mat& dst, const Mat& mask=Mat(), bool invertMask=false);
+void set(Mat& dst, const Scalar& gamma, const Mat& mask=Mat());
 
 // working with multi-channel arrays
-CV_EXPORTS void extract( const Mat& a, Mat& plane, int coi );
-CV_EXPORTS void insert( const Mat& plane, Mat& a, int coi );
+void extract( const Mat& a, Mat& plane, int coi );
+void insert( const Mat& plane, Mat& a, int coi );
 
 // checks that the array does not have NaNs and/or Infs and all the elements are
 // within [min_val,max_val). idx is the index of the first "bad" element.
-CV_EXPORTS int check( const Mat& data, double min_val, double max_val, vector<int>* idx );
+int check( const Mat& data, double min_val, double max_val, vector<int>* idx );
 
 // modifies values that are close to zero
-CV_EXPORTS void  patchZeros( Mat& mat, double level );
+void  patchZeros( Mat& mat, double level );
 
-CV_EXPORTS void transpose(const Mat& src, Mat& dst);
-CV_EXPORTS void erode(const Mat& src, Mat& dst, const Mat& _kernel, Point anchor=Point(-1,-1),
+void transpose(const Mat& src, Mat& dst);
+void erode(const Mat& src, Mat& dst, const Mat& _kernel, Point anchor=Point(-1,-1),
                       int borderType=0, const Scalar& borderValue=Scalar());
-CV_EXPORTS void dilate(const Mat& src, Mat& dst, const Mat& _kernel, Point anchor=Point(-1,-1),
+void dilate(const Mat& src, Mat& dst, const Mat& _kernel, Point anchor=Point(-1,-1),
                        int borderType=0, const Scalar& borderValue=Scalar());
-CV_EXPORTS void filter2D(const Mat& src, Mat& dst, int ddepth, const Mat& kernel,
+void filter2D(const Mat& src, Mat& dst, int ddepth, const Mat& kernel,
                          Point anchor, double delta, int borderType,
                          const Scalar& borderValue=Scalar());
-CV_EXPORTS void copyMakeBorder(const Mat& src, Mat& dst, int top, int bottom, int left, int right,
+void copyMakeBorder(const Mat& src, Mat& dst, int top, int bottom, int left, int right,
                                int borderType, const Scalar& borderValue=Scalar());
-CV_EXPORTS Mat calcSobelKernel2D( int dx, int dy, int apertureSize, int origin=0 );
-CV_EXPORTS Mat calcLaplaceKernel2D( int aperture_size );
+Mat calcSobelKernel2D( int dx, int dy, int apertureSize, int origin=0 );
+Mat calcLaplaceKernel2D( int aperture_size );
 
-CV_EXPORTS void initUndistortMap( const Mat& a, const Mat& k, Size sz, Mat& mapx, Mat& mapy );
+void initUndistortMap( const Mat& a, const Mat& k, Size sz, Mat& mapx, Mat& mapy );
 
-CV_EXPORTS void minMaxLoc(const Mat& src, double* minval, double* maxval,
+void minMaxLoc(const Mat& src, double* minval, double* maxval,
                           vector<int>* minloc, vector<int>* maxloc, const Mat& mask=Mat());
-CV_EXPORTS double norm(InputArray src, int normType, InputArray mask=noArray());
-CV_EXPORTS double norm(InputArray src1, InputArray src2, int normType, InputArray mask=noArray());
-CV_EXPORTS Scalar mean(const Mat& src, const Mat& mask=Mat());
-CV_EXPORTS double PSNR(InputArray src1, InputArray src2);
+double norm(InputArray src, int normType, InputArray mask=noArray());
+double norm(InputArray src1, InputArray src2, int normType, InputArray mask=noArray());
+Scalar mean(const Mat& src, const Mat& mask=Mat());
+double PSNR(InputArray src1, InputArray src2);
 
-CV_EXPORTS bool cmpUlps(const Mat& data, const Mat& refdata, int expMaxDiff, double* realMaxDiff, vector<int>* idx);
+bool cmpUlps(const Mat& data, const Mat& refdata, int expMaxDiff, double* realMaxDiff, vector<int>* idx);
 
 // compares two arrays. max_diff is the maximum actual difference,
 // success_err_level is maximum allowed difference, idx is the index of the first
 // element for which difference is >success_err_level
 // (or index of element with the maximum difference)
-CV_EXPORTS int cmpEps( const Mat& data, const Mat& refdata, double* max_diff,
+int cmpEps( const Mat& data, const Mat& refdata, double* max_diff,
                        double success_err_level, vector<int>* idx,
                        bool element_wise_relative_error );
 
 // a wrapper for the previous function. in case of error prints the message to log file.
-CV_EXPORTS int cmpEps2( TS* ts, const Mat& data, const Mat& refdata, double success_err_level,
+int cmpEps2( TS* ts, const Mat& data, const Mat& refdata, double success_err_level,
                         bool element_wise_relative_error, const char* desc );
 
-CV_EXPORTS int cmpEps2_64f( TS* ts, const double* val, const double* refval, int len,
+int cmpEps2_64f( TS* ts, const double* val, const double* refval, int len,
                         double eps, const char* param_name );
 
-CV_EXPORTS void logicOp(const Mat& src1, const Mat& src2, Mat& dst, char c);
-CV_EXPORTS void logicOp(const Mat& src, const Scalar& s, Mat& dst, char c);
-CV_EXPORTS void min(const Mat& src1, const Mat& src2, Mat& dst);
-CV_EXPORTS void min(const Mat& src, double s, Mat& dst);
-CV_EXPORTS void max(const Mat& src1, const Mat& src2, Mat& dst);
-CV_EXPORTS void max(const Mat& src, double s, Mat& dst);
+void logicOp(const Mat& src1, const Mat& src2, Mat& dst, char c);
+void logicOp(const Mat& src, const Scalar& s, Mat& dst, char c);
+void min(const Mat& src1, const Mat& src2, Mat& dst);
+void min(const Mat& src, double s, Mat& dst);
+void max(const Mat& src1, const Mat& src2, Mat& dst);
+void max(const Mat& src, double s, Mat& dst);
 
-CV_EXPORTS void compare(const Mat& src1, const Mat& src2, Mat& dst, int cmpop);
-CV_EXPORTS void compare(const Mat& src, double s, Mat& dst, int cmpop);
-CV_EXPORTS void gemm(const Mat& src1, const Mat& src2, double alpha,
+void compare(const Mat& src1, const Mat& src2, Mat& dst, int cmpop);
+void compare(const Mat& src, double s, Mat& dst, int cmpop);
+void gemm(const Mat& src1, const Mat& src2, double alpha,
                      const Mat& src3, double beta, Mat& dst, int flags);
-CV_EXPORTS void transform( const Mat& src, Mat& dst, const Mat& transmat, const Mat& shift );
-CV_EXPORTS double crossCorr(const Mat& src1, const Mat& src2);
-CV_EXPORTS void threshold( const Mat& src, Mat& dst, double thresh, double maxval, int thresh_type );
-CV_EXPORTS void minMaxIdx( InputArray _img, double* minVal, double* maxVal,
+void transform( const Mat& src, Mat& dst, const Mat& transmat, const Mat& shift );
+double crossCorr(const Mat& src1, const Mat& src2);
+void threshold( const Mat& src, Mat& dst, double thresh, double maxval, int thresh_type );
+void minMaxIdx( InputArray _img, double* minVal, double* maxVal,
                     Point* minLoc, Point* maxLoc, InputArray _mask );
 
-struct CV_EXPORTS MatInfo
+struct MatInfo
 {
     MatInfo(const Mat& _m) : m(&_m) {}
     const Mat* m;
 };
 
-CV_EXPORTS std::ostream& operator << (std::ostream& out, const MatInfo& m);
+std::ostream& operator << (std::ostream& out, const MatInfo& m);
 
-struct CV_EXPORTS MatComparator
+struct MatComparator
 {
 public:
     MatComparator(double maxdiff, int context);
@@ -228,7 +228,7 @@ struct CV_EXPORTS MatComparator
 class BaseTest;
 class TS;
 
-class CV_EXPORTS BaseTest
+class BaseTest
 {
 public:
     // constructor(s) and destructor
@@ -312,7 +312,7 @@ struct TestInfo
 \*****************************************************************************************/
 
 // common parameters:
-struct CV_EXPORTS TSParams
+struct TSParams
 {
     TSParams();
 
@@ -327,7 +327,7 @@ struct CV_EXPORTS TSParams
 };
 
 
-class CV_EXPORTS TS
+class TS
 {
 public:
     // constructor(s) and destructor
@@ -473,7 +473,7 @@ class CV_EXPORTS TS
 *            Subclass of BaseTest for testing functions that process dense arrays           *
 \*****************************************************************************************/
 
-class CV_EXPORTS ArrayTest : public BaseTest
+class ArrayTest : public BaseTest
 {
 public:
     // constructor(s) and destructor
@@ -510,7 +510,7 @@ class CV_EXPORTS ArrayTest : public BaseTest
 };
 
 
-class CV_EXPORTS BadArgTest : public BaseTest
+class BadArgTest : public BaseTest
 {
 public:
     // constructor(s) and destructor
@@ -564,7 +564,7 @@ class CV_EXPORTS BadArgTest : public BaseTest
 
 extern uint64 param_seed;
 
-struct CV_EXPORTS DefaultRngAuto
+struct DefaultRngAuto
 {
     const uint64 old_state;
 
@@ -576,16 +576,16 @@ struct CV_EXPORTS DefaultRngAuto
 
 
 // test images generation functions
-CV_EXPORTS void fillGradient(Mat& img, int delta = 5);
-CV_EXPORTS void smoothBorder(Mat& img, const Scalar& color, int delta = 3);
+void fillGradient(Mat& img, int delta = 5);
+void smoothBorder(Mat& img, const Scalar& color, int delta = 3);
 
-CV_EXPORTS void printVersionInfo(bool useStdOut = true);
+void printVersionInfo(bool useStdOut = true);
 
 
 // Utility functions
 
-CV_EXPORTS void addDataSearchPath(const std::string& path);
-CV_EXPORTS void addDataSearchSubDirectory(const std::string& subdir);
+void addDataSearchPath(const std::string& path);
+void addDataSearchSubDirectory(const std::string& subdir);
 
 /*! @brief Try to find requested data file
 
@@ -603,7 +603,7 @@ CV_EXPORTS void addDataSearchSubDirectory(const std::string& subdir);
   - modulename from TS::init()
 
  */
-CV_EXPORTS std::string findDataFile(const std::string& relative_path, bool required = true);
+std::string findDataFile(const std::string& relative_path, bool required = true);
 
 
 #ifndef __CV_TEST_EXEC_ARGS
diff --git a/modules/ts/include/opencv2/ts/cuda_perf.hpp b/modules/ts/include/opencv2/ts/cuda_perf.hpp
index c0c2b7dad5de..5d5275060193 100644
--- a/modules/ts/include/opencv2/ts/cuda_perf.hpp
+++ b/modules/ts/include/opencv2/ts/cuda_perf.hpp
@@ -88,7 +88,7 @@ namespace perf
             SANITY_CHECK(cpu_##mat, ## __VA_ARGS__); \
         } while(0)
 
-    CV_EXPORTS cv::Mat readImage(const std::string& fileName, int flags = cv::IMREAD_COLOR);
+    cv::Mat readImage(const std::string& fileName, int flags = cv::IMREAD_COLOR);
 
     struct CvtColorInfo
     {
@@ -99,11 +99,11 @@ namespace perf
         CvtColorInfo() {}
         explicit CvtColorInfo(int scn_, int dcn_, int code_) : scn(scn_), dcn(dcn_), code(code_) {}
     };
-    CV_EXPORTS void PrintTo(const CvtColorInfo& info, std::ostream* os);
+    void PrintTo(const CvtColorInfo& info, std::ostream* os);
 
-    CV_EXPORTS void printCudaInfo();
+    void printCudaInfo();
 
-    CV_EXPORTS void sortKeyPoints(std::vector<cv::KeyPoint>& keypoints, cv::InputOutputArray _descriptors = cv::noArray());
+    void sortKeyPoints(std::vector<cv::KeyPoint>& keypoints, cv::InputOutputArray _descriptors = cv::noArray());
 
 #ifdef HAVE_CUDA
     #define CV_PERF_TEST_CUDA_MAIN(modulename) \
diff --git a/modules/ts/include/opencv2/ts/cuda_test.hpp b/modules/ts/include/opencv2/ts/cuda_test.hpp
index 4100d295628d..53bdbc8a4f10 100644
--- a/modules/ts/include/opencv2/ts/cuda_test.hpp
+++ b/modules/ts/include/opencv2/ts/cuda_test.hpp
@@ -53,34 +53,34 @@ namespace cvtest
     //////////////////////////////////////////////////////////////////////
     // random generators
 
-    CV_EXPORTS int randomInt(int minVal, int maxVal);
-    CV_EXPORTS double randomDouble(double minVal, double maxVal);
-    CV_EXPORTS cv::Size randomSize(int minVal, int maxVal);
-    CV_EXPORTS cv::Scalar randomScalar(double minVal, double maxVal);
-    CV_EXPORTS cv::Mat randomMat(cv::Size size, int type, double minVal = 0.0, double maxVal = 255.0);
+    int randomInt(int minVal, int maxVal);
+    double randomDouble(double minVal, double maxVal);
+    cv::Size randomSize(int minVal, int maxVal);
+    cv::Scalar randomScalar(double minVal, double maxVal);
+    cv::Mat randomMat(cv::Size size, int type, double minVal = 0.0, double maxVal = 255.0);
 
     //////////////////////////////////////////////////////////////////////
     // GpuMat create
 
-    CV_EXPORTS cv::cuda::GpuMat createMat(cv::Size size, int type, bool useRoi = false);
-    CV_EXPORTS cv::cuda::GpuMat loadMat(const cv::Mat& m, bool useRoi = false);
+    cv::cuda::GpuMat createMat(cv::Size size, int type, bool useRoi = false);
+    cv::cuda::GpuMat loadMat(const cv::Mat& m, bool useRoi = false);
 
     //////////////////////////////////////////////////////////////////////
     // Image load
 
     //! read image from testdata folder
-    CV_EXPORTS cv::Mat readImage(const std::string& fileName, int flags = cv::IMREAD_COLOR);
+    cv::Mat readImage(const std::string& fileName, int flags = cv::IMREAD_COLOR);
 
     //! read image from testdata folder and convert it to specified type
-    CV_EXPORTS cv::Mat readImageType(const std::string& fname, int type);
+    cv::Mat readImageType(const std::string& fname, int type);
 
     //////////////////////////////////////////////////////////////////////
     // Gpu devices
 
     //! return true if device supports specified feature and gpu module was built with support the feature.
-    CV_EXPORTS bool supportFeature(const cv::cuda::DeviceInfo& info, cv::cuda::FeatureSet feature);
+    bool supportFeature(const cv::cuda::DeviceInfo& info, cv::cuda::FeatureSet feature);
 
-    class CV_EXPORTS DeviceManager
+    class DeviceManager
     {
     public:
         static DeviceManager& instance();
@@ -99,11 +99,11 @@ namespace cvtest
     //////////////////////////////////////////////////////////////////////
     // Additional assertion
 
-    CV_EXPORTS void minMaxLocGold(const cv::Mat& src, double* minVal_, double* maxVal_ = 0, cv::Point* minLoc_ = 0, cv::Point* maxLoc_ = 0, const cv::Mat& mask = cv::Mat());
+    void minMaxLocGold(const cv::Mat& src, double* minVal_, double* maxVal_ = 0, cv::Point* minLoc_ = 0, cv::Point* maxLoc_ = 0, const cv::Mat& mask = cv::Mat());
 
-    CV_EXPORTS cv::Mat getMat(cv::InputArray arr);
+    cv::Mat getMat(cv::InputArray arr);
 
-    CV_EXPORTS testing::AssertionResult assertMatNear(const char* expr1, const char* expr2, const char* eps_expr, cv::InputArray m1, cv::InputArray m2, double eps);
+    testing::AssertionResult assertMatNear(const char* expr1, const char* expr2, const char* eps_expr, cv::InputArray m1, cv::InputArray m2, double eps);
 
     #undef EXPECT_MAT_NEAR
     #define EXPECT_MAT_NEAR(m1, m2, eps) EXPECT_PRED_FORMAT3(cvtest::assertMatNear, m1, m2, eps)
@@ -148,7 +148,7 @@ namespace cvtest
             ASSERT_NEAR(p1.z, p2.z, eps); \
         }
 
-    CV_EXPORTS double checkSimilarity(cv::InputArray m1, cv::InputArray m2);
+    double checkSimilarity(cv::InputArray m1, cv::InputArray m2);
 
     #undef EXPECT_MAT_SIMILAR
     #define EXPECT_MAT_SIMILAR(mat1, mat2, eps) \
@@ -248,10 +248,10 @@ namespace cvtest
     using perf::MatType;
 
     //! return vector with types from specified range.
-    CV_EXPORTS std::vector<MatType> types(int depth_start, int depth_end, int cn_start, int cn_end);
+    std::vector<MatType> types(int depth_start, int depth_end, int cn_start, int cn_end);
 
     //! return vector with all types (depth: CV_8U-CV_64F, channels: 1-4).
-    CV_EXPORTS const std::vector<MatType>& all_types();
+    const std::vector<MatType>& all_types();
 
     #define ALL_TYPES testing::ValuesIn(all_types())
     #define TYPES(depth_start, depth_end, cn_start, cn_end) testing::ValuesIn(types(depth_start, depth_end, cn_start, cn_end))
@@ -269,7 +269,7 @@ namespace cvtest
         bool val_;
     };
 
-    CV_EXPORTS void PrintTo(const UseRoi& useRoi, std::ostream* os);
+    void PrintTo(const UseRoi& useRoi, std::ostream* os);
 
     #define WHOLE_SUBMAT testing::Values(UseRoi(false), UseRoi(true))
 
@@ -286,7 +286,7 @@ namespace cvtest
         bool val_;
     };
 
-    CV_EXPORTS void PrintTo(const Inverse& useRoi, std::ostream* os);
+    void PrintTo(const Inverse& useRoi, std::ostream* os);
 
     #define DIRECT_INVERSE testing::Values(Inverse(false), Inverse(true))
 
@@ -325,26 +325,26 @@ namespace cvtest
     //////////////////////////////////////////////////////////////////////
     // Features2D
 
-    CV_EXPORTS testing::AssertionResult assertKeyPointsEquals(const char* gold_expr, const char* actual_expr, std::vector<cv::KeyPoint>& gold, std::vector<cv::KeyPoint>& actual);
+    testing::AssertionResult assertKeyPointsEquals(const char* gold_expr, const char* actual_expr, std::vector<cv::KeyPoint>& gold, std::vector<cv::KeyPoint>& actual);
 
     #define ASSERT_KEYPOINTS_EQ(gold, actual) EXPECT_PRED_FORMAT2(assertKeyPointsEquals, gold, actual)
 
-    CV_EXPORTS int getMatchedPointsCount(std::vector<cv::KeyPoint>& gold, std::vector<cv::KeyPoint>& actual);
-    CV_EXPORTS int getMatchedPointsCount(const std::vector<cv::KeyPoint>& keypoints1, const std::vector<cv::KeyPoint>& keypoints2, const std::vector<cv::DMatch>& matches);
+    int getMatchedPointsCount(std::vector<cv::KeyPoint>& gold, std::vector<cv::KeyPoint>& actual);
+    int getMatchedPointsCount(const std::vector<cv::KeyPoint>& keypoints1, const std::vector<cv::KeyPoint>& keypoints2, const std::vector<cv::DMatch>& matches);
 
     //////////////////////////////////////////////////////////////////////
     // Other
 
-    CV_EXPORTS void dumpImage(const std::string& fileName, const cv::Mat& image);
-    CV_EXPORTS void showDiff(cv::InputArray gold, cv::InputArray actual, double eps);
+    void dumpImage(const std::string& fileName, const cv::Mat& image);
+    void showDiff(cv::InputArray gold, cv::InputArray actual, double eps);
 
-    CV_EXPORTS void parseCudaDeviceOptions(int argc, char **argv);
-    CV_EXPORTS void printCudaInfo();
+    void parseCudaDeviceOptions(int argc, char **argv);
+    void printCudaInfo();
 }
 
 namespace cv { namespace cuda
 {
-    CV_EXPORTS void PrintTo(const DeviceInfo& info, std::ostream* os);
+    void PrintTo(const DeviceInfo& info, std::ostream* os);
 }}
 
 #ifdef HAVE_CUDA
diff --git a/modules/ts/include/opencv2/ts/ocl_perf.hpp b/modules/ts/include/opencv2/ts/ocl_perf.hpp
index ce25b7193bff..aa87243a4fcd 100644
--- a/modules/ts/include/opencv2/ts/ocl_perf.hpp
+++ b/modules/ts/include/opencv2/ts/ocl_perf.hpp
@@ -119,11 +119,11 @@ using namespace perf;
 namespace perf {
 
 // Check for current device limitation
-CV_EXPORTS void checkDeviceMaxMemoryAllocSize(const Size& size, int type, int factor = 1);
+void checkDeviceMaxMemoryAllocSize(const Size& size, int type, int factor = 1);
 
 // Initialize Mat with random numbers. Range is depends on the data type.
 // TODO Parameter type is actually OutputArray
-CV_EXPORTS void randu(InputOutputArray dst);
+void randu(InputOutputArray dst);
 
 inline void safeFinish()
 {
diff --git a/modules/ts/include/opencv2/ts/ocl_test.hpp b/modules/ts/include/opencv2/ts/ocl_test.hpp
index 294fab472cef..ee86f49ce9bd 100644
--- a/modules/ts/include/opencv2/ts/ocl_test.hpp
+++ b/modules/ts/include/opencv2/ts/ocl_test.hpp
@@ -105,10 +105,10 @@ do \
 #define EXPECT_MAT_NEAR_RELATIVE(mat1, mat2, eps) \
 do \
 { \
-    ASSERT_EQ(mat1.type(), mat2.type()); \
-    ASSERT_EQ(mat1.size(), mat2.size()); \
-    EXPECT_LE(TestUtils::checkNormRelative(mat1, mat2), eps) \
-        << "Size: " << mat1.size() << std::endl; \
+    ASSERT_EQ((mat1).type(), (mat2).type()); \
+    ASSERT_EQ((mat1).size(), (mat2).size()); \
+    EXPECT_LE(TestUtils::checkNormRelative((mat1), (mat2)), eps) \
+        << "Size: " << (mat1).size() << std::endl; \
 } while ((void)0, 0)
 
 #define EXPECT_MAT_N_DIFF(mat1, mat2, num) \
@@ -192,7 +192,7 @@ using perf::MatType;
 
 #define OCL_RNG_SEED 123456
 
-struct CV_EXPORTS TestUtils
+struct TestUtils
 {
     cv::RNG rng;
 
@@ -319,7 +319,7 @@ do \
 #define UMAT_UPLOAD_OUTPUT_PARAMETER(name) UMAT_UPLOAD_INPUT_PARAMETER(name)
 
 template <typename T>
-struct CV_EXPORTS TSTestWithParam : public TestUtils, public ::testing::TestWithParam<T>
+struct TSTestWithParam : public TestUtils, public ::testing::TestWithParam<T>
 {
 
 };
diff --git a/modules/ts/include/opencv2/ts/ts_gtest.h b/modules/ts/include/opencv2/ts/ts_gtest.h
index 9f54cbb77c37..fb31603bb0e1 100644
--- a/modules/ts/include/opencv2/ts/ts_gtest.h
+++ b/modules/ts/include/opencv2/ts/ts_gtest.h
@@ -2295,7 +2295,7 @@ using ::std::tuple_size;
 #endif // _MSC_VER
 
 #ifndef GTEST_API_
-# define GTEST_API_ CV_EXPORTS
+# define GTEST_API_
 #endif
 
 #ifdef __GNUC__
diff --git a/modules/ts/include/opencv2/ts/ts_perf.hpp b/modules/ts/include/opencv2/ts/ts_perf.hpp
index 37813658dfbd..8a39f66473a0 100644
--- a/modules/ts/include/opencv2/ts/ts_perf.hpp
+++ b/modules/ts/include/opencv2/ts/ts_perf.hpp
@@ -172,7 +172,7 @@ enum ERROR_TYPE
     ERROR_RELATIVE = 1
 };
 
-class CV_EXPORTS Regression
+class Regression
 {
 public:
     static Regression& add(TestBase* test, const std::string& name, cv::InputArray array, double eps = DBL_EPSILON, ERROR_TYPE err = ERROR_ABSOLUTE);
@@ -219,7 +219,7 @@ class CV_EXPORTS Regression
 #define SANITY_CHECK_MATCHES(array, ...) ::perf::Regression::addMatches(this, #array, array , ## __VA_ARGS__)
 #define SANITY_CHECK_NOTHING() this->setVerified()
 
-class CV_EXPORTS GpuPerf
+class GpuPerf
 {
 public:
   static bool targetDevice();
@@ -230,7 +230,7 @@ class CV_EXPORTS GpuPerf
 /*****************************************************************************************\
 *                            Container for performance metrics                            *
 \*****************************************************************************************/
-typedef struct CV_EXPORTS performance_metrics
+typedef struct performance_metrics
 {
     size_t bytesIn;
     size_t bytesOut;
@@ -372,7 +372,7 @@ class InstumentData
 };
 #endif
 
-class CV_EXPORTS TestBase: public ::testing::Test
+class TestBase: public ::testing::Test
 {
 public:
     TestBase();
@@ -463,7 +463,7 @@ class CV_EXPORTS TestBase: public ::testing::Test
     static cv::Size getSize(cv::InputArray a);
     static void declareArray(SizeVector& sizes, cv::InputOutputArray a, WarmUpType wtype);
 
-    class CV_EXPORTS _declareHelper
+    class _declareHelper
     {
     public:
         _declareHelper& in(cv::InputOutputArray a1, WarmUpType wtype = WARMUP_READ);
@@ -507,15 +507,15 @@ typedef TestBaseWithParam<Size_MatType_t> Size_MatType;
 /*****************************************************************************************\
 *                              Print functions for googletest                             *
 \*****************************************************************************************/
-CV_EXPORTS void PrintTo(const MatType& t, std::ostream* os);
+void PrintTo(const MatType& t, std::ostream* os);
 
 } //namespace perf
 
 namespace cv
 {
 
-CV_EXPORTS void PrintTo(const String& str, ::std::ostream* os);
-CV_EXPORTS void PrintTo(const Size& sz, ::std::ostream* os);
+void PrintTo(const String& str, ::std::ostream* os);
+void PrintTo(const Size& sz, ::std::ostream* os);
 
 } //namespace cv
 
@@ -706,7 +706,7 @@ namespace comparators
 {
 
 template<typename T>
-struct CV_EXPORTS RectLess_ :
+struct RectLess_ :
         public std::binary_function<cv::Rect_<T>, cv::Rect_<T>, bool>
 {
   bool operator()(const cv::Rect_<T>& r1, const cv::Rect_<T>& r2) const
@@ -720,7 +720,7 @@ struct CV_EXPORTS RectLess_ :
 
 typedef RectLess_<int> RectLess;
 
-struct CV_EXPORTS KeypointGreater :
+struct KeypointGreater :
         public std::binary_function<cv::KeyPoint, cv::KeyPoint, bool>
 {
     bool operator()(const cv::KeyPoint& kp1, const cv::KeyPoint& kp2) const
@@ -739,7 +739,7 @@ struct CV_EXPORTS KeypointGreater :
 
 } //namespace comparators
 
-void CV_EXPORTS sort(std::vector<cv::KeyPoint>& pts, cv::InputOutputArray descriptors);
+void sort(std::vector<cv::KeyPoint>& pts, cv::InputOutputArray descriptors);
 } //namespace perf
 
 #endif //OPENCV_TS_PERF_HPP
diff --git a/modules/ts/src/cuda_test.cpp b/modules/ts/src/cuda_test.cpp
index eb4cee136220..25e2ebf48d30 100644
--- a/modules/ts/src/cuda_test.cpp
+++ b/modules/ts/src/cuda_test.cpp
@@ -51,7 +51,7 @@ using namespace testing::internal;
 
 namespace perf
 {
-    CV_EXPORTS void printCudaInfo();
+    void printCudaInfo();
 }
 
 namespace cvtest
diff --git a/modules/ts/src/ts.cpp b/modules/ts/src/ts.cpp
index 525110290dae..5510d451c5bc 100644
--- a/modules/ts/src/ts.cpp
+++ b/modules/ts/src/ts.cpp
@@ -742,12 +742,12 @@ static bool isDirectory(const std::string& path)
 #endif
 }
 
-CV_EXPORTS void addDataSearchPath(const std::string& path)
+void addDataSearchPath(const std::string& path)
 {
     if (isDirectory(path))
         TS::ptr()->data_search_path.push_back(path);
 }
-CV_EXPORTS void addDataSearchSubDirectory(const std::string& subdir)
+void addDataSearchSubDirectory(const std::string& subdir)
 {
     TS::ptr()->data_search_subdir.push_back(subdir);
 }
diff --git a/platforms/android/android.toolchain.cmake b/platforms/android/android.toolchain.cmake
index 6d64f9214883..751a33aec205 100644
--- a/platforms/android/android.toolchain.cmake
+++ b/platforms/android/android.toolchain.cmake
@@ -1375,14 +1375,9 @@ if( ARMEABI_V7A_HARD )
 endif()
 
 if( ANDROID_NO_UNDEFINED )
- if( MIPS )
-  # there is some sysroot-related problem in mips linker...
   if( NOT ANDROID_SYSROOT MATCHES "[ ;\"]" )
-   set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -Wl,--no-undefined -Wl,-rpath-link,${ANDROID_SYSROOT}/usr/lib" )
+   set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -Wl,--no-undefined -Wl,-rpath-link,${ANDROID_SYSROOT}/usr/lib:${ANDROID_SYSROOT}/usr/lib64" )
   endif()
- else()
-  set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -Wl,--no-undefined" )
- endif()
 endif()
 
 if( ANDROID_SO_UNDEFINED )
diff --git a/samples/CMakeLists.txt b/samples/CMakeLists.txt
index 1ce0489f1aa7..eae394d87c2d 100644
--- a/samples/CMakeLists.txt
+++ b/samples/CMakeLists.txt
@@ -58,6 +58,9 @@ if(MSVC)
   if(NOT ENABLE_BUILD_HARDENING)
     add_definitions(-D_CRT_SECURE_NO_WARNINGS)
   endif()
+  # C4251: ... needs to have dll-interface to be used by clients of ...
+  # C4275: non dll-interface class ... used as base for dll-interface class ...
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4251 /wd4275")
 
   if(NOT OpenCV_SHARED)
     foreach(flag_var