Merge remote-tracking branch 'upstream/3.4' into merge-3.4

3rdparty/quirc/CMakeLists.txt

+project(quirc)
+
+set(CURR_INCLUDE_DIR "${CMAKE_CURRENT_LIST_DIR}/include")
+
+set_property(GLOBAL PROPERTY QUIRC_INCLUDE_DIR ${CURR_INCLUDE_DIR})
+ocv_include_directories(${CURR_INCLUDE_DIR})
+
+file(GLOB_RECURSE quirc_headers RELATIVE "${CMAKE_CURRENT_LIST_DIR}" "include/*.h")
+file(GLOB_RECURSE quirc_sources RELATIVE "${CMAKE_CURRENT_LIST_DIR}" "src/*.c")
+
+add_library(${PROJECT_NAME} STATIC ${quirc_headers} ${quirc_sources})
+ocv_warnings_disable(CMAKE_C_FLAGS -Wunused-variable -Wshadow)
+
+set_target_properties(${PROJECT_NAME}
+  PROPERTIES OUTPUT_NAME ${PROJECT_NAME}
+  DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
+  COMPILE_PDB_NAME ${PROJECT_NAME}
+  COMPILE_PDB_NAME_DEBUG "${PROJECT_NAME}${OPENCV_DEBUG_POSTFIX}"
+  ARCHIVE_OUTPUT_DIRECTORY ${3P_LIBRARY_OUTPUT_PATH}
+  )
+
+if(ENABLE_SOLUTION_FOLDERS)
+  set_target_properties(${PROJECT_NAME} PROPERTIES FOLDER "3rdparty")
+endif()
+
+if(NOT BUILD_SHARED_LIBS)
+  ocv_install_target(${PROJECT_NAME} EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev)
+endif()
+
+ocv_install_3rdparty_licenses(${PROJECT_NAME} LICENSE)

3rdparty/quirc/LICENSE

+quirc -- QR-code recognition library
+Copyright (C) 2010-2012 Daniel Beer <dlbeer@gmail.com>
+
+Permission to use, copy, modify, and/or distribute this software for
+any purpose with or without fee is hereby granted, provided that the
+above copyright notice and this permission notice appear in all
+copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

3rdparty/quirc/include/quirc.h

+/* quirc -- QR-code recognition library
+ * Copyright (C) 2010-2012 Daniel Beer <dlbeer@gmail.com>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef QUIRC_H_
+#define QUIRC_H_
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct quirc;
+
+/* Obtain the library version string. */
+const char *quirc_version(void);
+
+/* Construct a new QR-code recognizer. This function will return NULL
+ * if sufficient memory could not be allocated.
+ */
+struct quirc *quirc_new(void);
+
+/* Destroy a QR-code recognizer. */
+void quirc_destroy(struct quirc *q);
+
+/* Resize the QR-code recognizer. The size of an image must be
+ * specified before codes can be analyzed.
+ *
+ * This function returns 0 on success, or -1 if sufficient memory could
+ * not be allocated.
+ */
+int quirc_resize(struct quirc *q, int w, int h);
+
+/* These functions are used to process images for QR-code recognition.
+ * quirc_begin() must first be called to obtain access to a buffer into
+ * which the input image should be placed. Optionally, the current
+ * width and height may be returned.
+ *
+ * After filling the buffer, quirc_end() should be called to process
+ * the image for QR-code recognition. The locations and content of each
+ * code may be obtained using accessor functions described below.
+ */
+uint8_t *quirc_begin(struct quirc *q, int *w, int *h);
+void quirc_end(struct quirc *q);
+
+/* This structure describes a location in the input image buffer. */
+struct quirc_point {
+	int	x;
+	int	y;
+};
+
+/* This enum describes the various decoder errors which may occur. */
+typedef enum {
+	QUIRC_SUCCESS = 0,
+	QUIRC_ERROR_INVALID_GRID_SIZE,
+	QUIRC_ERROR_INVALID_VERSION,
+	QUIRC_ERROR_FORMAT_ECC,
+	QUIRC_ERROR_DATA_ECC,
+	QUIRC_ERROR_UNKNOWN_DATA_TYPE,
+	QUIRC_ERROR_DATA_OVERFLOW,
+	QUIRC_ERROR_DATA_UNDERFLOW
+} quirc_decode_error_t;
+
+/* Return a string error message for an error code. */
+const char *quirc_strerror(quirc_decode_error_t err);
+
+/* Limits on the maximum size of QR-codes and their content. */
+#define QUIRC_MAX_BITMAP	3917
+#define QUIRC_MAX_PAYLOAD	8896
+
+/* QR-code ECC types. */
+#define QUIRC_ECC_LEVEL_M     0
+#define QUIRC_ECC_LEVEL_L     1
+#define QUIRC_ECC_LEVEL_H     2
+#define QUIRC_ECC_LEVEL_Q     3
+
+/* QR-code data types. */
+#define QUIRC_DATA_TYPE_NUMERIC       1
+#define QUIRC_DATA_TYPE_ALPHA         2
+#define QUIRC_DATA_TYPE_BYTE          4
+#define QUIRC_DATA_TYPE_KANJI         8
+
+/* Common character encodings */
+#define QUIRC_ECI_ISO_8859_1		1
+#define QUIRC_ECI_IBM437		2
+#define QUIRC_ECI_ISO_8859_2		4
+#define QUIRC_ECI_ISO_8859_3		5
+#define QUIRC_ECI_ISO_8859_4		6
+#define QUIRC_ECI_ISO_8859_5		7
+#define QUIRC_ECI_ISO_8859_6		8
+#define QUIRC_ECI_ISO_8859_7		9
+#define QUIRC_ECI_ISO_8859_8		10
+#define QUIRC_ECI_ISO_8859_9		11
+#define QUIRC_ECI_WINDOWS_874		13
+#define QUIRC_ECI_ISO_8859_13		15
+#define QUIRC_ECI_ISO_8859_15		17
+#define QUIRC_ECI_SHIFT_JIS		20
+#define QUIRC_ECI_UTF_8			26
+
+/* This structure is used to return information about detected QR codes
+ * in the input image.
+ */
+struct quirc_code {
+	/* The four corners of the QR-code, from top left, clockwise */
+	struct quirc_point	corners[4];
+
+	/* The number of cells across in the QR-code. The cell bitmap
+	 * is a bitmask giving the actual values of cells. If the cell
+	 * at (x, y) is black, then the following bit is set:
+	 *
+	 *     cell_bitmap[i >> 3] & (1 << (i & 7))
+	 *
+	 * where i = (y * size) + x.
+	 */
+	int			size;
+	uint8_t			cell_bitmap[QUIRC_MAX_BITMAP];
+};
+
+/* This structure holds the decoded QR-code data */
+struct quirc_data {
+	/* Various parameters of the QR-code. These can mostly be
+	 * ignored if you only care about the data.
+	 */
+	int			version;
+	int			ecc_level;
+	int			mask;
+
+	/* This field is the highest-valued data type found in the QR
+	 * code.
+	 */
+	int			data_type;
+
+	/* Data payload. For the Kanji datatype, payload is encoded as
+	 * Shift-JIS. For all other datatypes, payload is ASCII text.
+	 */
+	uint8_t			payload[QUIRC_MAX_PAYLOAD];
+	int			payload_len;
+
+	/* ECI assignment number */
+	uint32_t		eci;
+};
+
+/* Return the number of QR-codes identified in the last processed
+ * image.
+ */
+int quirc_count(const struct quirc *q);
+
+/* Extract the QR-code specified by the given index. */
+void quirc_extract(const struct quirc *q, int index,
+		   struct quirc_code *code);
+
+/* Decode a QR-code, returning the payload data. */
+quirc_decode_error_t quirc_decode(const struct quirc_code *code,
+				  struct quirc_data *data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

3rdparty/quirc/include/quirc_internal.h

+/* quirc -- QR-code recognition library
+ * Copyright (C) 2010-2012 Daniel Beer <dlbeer@gmail.com>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef QUIRC_INTERNAL_H_
+#define QUIRC_INTERNAL_H_
+
+#include <quirc.h>
+
+#define QUIRC_PIXEL_WHITE	0
+#define QUIRC_PIXEL_BLACK	1
+#define QUIRC_PIXEL_REGION	2
+
+#ifndef QUIRC_MAX_REGIONS
+#define QUIRC_MAX_REGIONS	254
+#endif
+#define QUIRC_MAX_CAPSTONES	32
+#define QUIRC_MAX_GRIDS		8
+
+#define QUIRC_PERSPECTIVE_PARAMS	8
+
+#if QUIRC_MAX_REGIONS < UINT8_MAX
+typedef uint8_t quirc_pixel_t;
+#elif QUIRC_MAX_REGIONS < UINT16_MAX
+typedef uint16_t quirc_pixel_t;
+#else
+#error "QUIRC_MAX_REGIONS > 65534 is not supported"
+#endif
+
+struct quirc_region {
+	struct quirc_point	seed;
+	int			count;
+	int			capstone;
+};
+
+struct quirc_capstone {
+	int			ring;
+	int			stone;
+
+	struct quirc_point	corners[4];
+	struct quirc_point	center;
+	double			c[QUIRC_PERSPECTIVE_PARAMS];
+
+	int			qr_grid;
+};
+
+struct quirc_grid {
+	/* Capstone indices */
+	int			caps[3];
+
+	/* Alignment pattern region and corner */
+	int			align_region;
+	struct quirc_point	align;
+
+	/* Timing pattern endpoints */
+	struct quirc_point	tpep[3];
+	int			hscan;
+	int			vscan;
+
+	/* Grid size and perspective transform */
+	int			grid_size;
+	double			c[QUIRC_PERSPECTIVE_PARAMS];
+};
+
+struct quirc {
+	uint8_t			*image;
+	quirc_pixel_t		*pixels;
+	int			*row_average; /* used by threshold() */
+	int			w;
+	int			h;
+
+	int			num_regions;
+	struct quirc_region	regions[QUIRC_MAX_REGIONS];
+
+	int			num_capstones;
+	struct quirc_capstone	capstones[QUIRC_MAX_CAPSTONES];
+
+	int			num_grids;
+	struct quirc_grid	grids[QUIRC_MAX_GRIDS];
+};
+
+/************************************************************************
+ * QR-code version information database
+ */
+
+#define QUIRC_MAX_VERSION     40
+#define QUIRC_MAX_ALIGNMENT   7
+
+struct quirc_rs_params {
+	int             bs; /* Small block size */
+	int             dw; /* Small data words */
+	int		ns; /* Number of small blocks */
+};
+
+struct quirc_version_info {
+	int				data_bytes;
+	int				apat[QUIRC_MAX_ALIGNMENT];
+	struct quirc_rs_params          ecc[4];
+};
+
+extern const struct quirc_version_info quirc_version_db[QUIRC_MAX_VERSION + 1];
+
+#endif

3rdparty/quirc/src/quirc.c

+/* quirc -- QR-code recognition library
+ * Copyright (C) 2010-2012 Daniel Beer <dlbeer@gmail.com>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <quirc_internal.h>
+
+const char *quirc_version(void)
+{
+	return "1.0";
+}
+
+struct quirc *quirc_new(void)
+{
+	struct quirc *q = malloc(sizeof(*q));
+
+	if (!q)
+		return NULL;
+
+	memset(q, 0, sizeof(*q));
+	return q;
+}
+
+void quirc_destroy(struct quirc *q)
+{
+	free(q->image);
+	/* q->pixels may alias q->image when their type representation is of the
+	   same size, so we need to be careful here to avoid a double free */
+	if (sizeof(*q->image) != sizeof(*q->pixels))
+		free(q->pixels);
+	free(q->row_average);
+	free(q);
+}
+
+int quirc_resize(struct quirc *q, int w, int h)
+{
+	uint8_t		*image  = NULL;
+	quirc_pixel_t	*pixels = NULL;
+	int		*row_average = NULL;
+
+	/*
+	 * XXX: w and h should be size_t (or at least unsigned) as negatives
+	 * values would not make much sense. The downside is that it would break
+	 * both the API and ABI. Thus, at the moment, let's just do a sanity
+	 * check.
+	 */
+	if (w < 0 || h < 0)
+		goto fail;
+
+	/*
+	 * alloc a new buffer for q->image. We avoid realloc(3) because we want
+	 * on failure to be leave `q` in a consistant, unmodified state.
+	 */
+	image = calloc(w, h);
+	if (!image)
+		goto fail;
+
+	/* compute the "old" (i.e. currently allocated) and the "new"
+	   (i.e. requested) image dimensions */
+	size_t olddim = q->w * q->h;
+	size_t newdim = w * h;
+	size_t min = (olddim < newdim ? olddim : newdim);
+
+	/*
+	 * copy the data into the new buffer, avoiding (a) to read beyond the
+	 * old buffer when the new size is greater and (b) to write beyond the
+	 * new buffer when the new size is smaller, hence the min computation.
+	 */
+	(void)memcpy(image, q->image, min);
+
+	/* alloc a new buffer for q->pixels if needed */
+	if (sizeof(*q->image) != sizeof(*q->pixels)) {
+		pixels = calloc(newdim, sizeof(quirc_pixel_t));
+		if (!pixels)
+			goto fail;
+	}
+
+	/* alloc a new buffer for q->row_average */
+	row_average = calloc(w, sizeof(int));
+	if (!row_average)
+		goto fail;
+
+	/* alloc succeeded, update `q` with the new size and buffers */
+	q->w = w;
+	q->h = h;
+	free(q->image);
+	q->image = image;
+	if (sizeof(*q->image) != sizeof(*q->pixels)) {
+		free(q->pixels);
+		q->pixels = pixels;
+	}
+	free(q->row_average);
+	q->row_average = row_average;
+
+	return 0;
+	/* NOTREACHED */
+fail:
+	free(image);
+	free(pixels);
+	free(row_average);
+
+	return -1;
+}
+
+int quirc_count(const struct quirc *q)
+{
+	return q->num_grids;
+}
+
+static const char *const error_table[] = {
+	[QUIRC_SUCCESS] = "Success",
+	[QUIRC_ERROR_INVALID_GRID_SIZE] = "Invalid grid size",
+	[QUIRC_ERROR_INVALID_VERSION] = "Invalid version",
+	[QUIRC_ERROR_FORMAT_ECC] = "Format data ECC failure",
+	[QUIRC_ERROR_DATA_ECC] = "ECC failure",
+	[QUIRC_ERROR_UNKNOWN_DATA_TYPE] = "Unknown data type",
+	[QUIRC_ERROR_DATA_OVERFLOW] = "Data overflow",
+	[QUIRC_ERROR_DATA_UNDERFLOW] = "Data underflow"
+};
+
+const char *quirc_strerror(quirc_decode_error_t err)
+{
+	if ((int)err < 8) { return error_table[err]; }
+	else { return "Unknown error"; }
+}

CMakeLists.txt

@@ -283,6 +283,7 @@ OCV_OPTION(WITH_IMGCODEC_HDR   "Include HDR support"                         ON)
 OCV_OPTION(WITH_IMGCODEC_SUNRASTER "Include SUNRASTER support"               ON)
 OCV_OPTION(WITH_IMGCODEC_PXM   "Include PNM (PBM,PGM,PPM) and PAM formats support" ON)
 OCV_OPTION(WITH_IMGCODEC_PFM   "Include PFM formats support"                 ON)
+OCV_OPTION(WITH_QUIRC          "Include library QR-code decoding"            ON)
 
 # OpenCV build components
 # ===================================================
@@ -696,6 +697,10 @@ if(WITH_OPENVX)
   include(cmake/FindOpenVX.cmake)
 endif()
 
+if(WITH_QUIRC)
+  add_subdirectory(3rdparty/quirc)
+  set(HAVE_QUIRC TRUE)
+endif()
 # ----------------------------------------------------------------------------
 # OpenCV HAL
 # ----------------------------------------------------------------------------

cmake/OpenCVModule.cmake

@@ -909,6 +909,13 @@ macro(_ocv_create_module)
       source_group("Src" FILES "${_VS_VERSION_FILE}")
     endif()
   endif()
+  if(WIN32 AND NOT ("${the_module}" STREQUAL "opencv_core" OR "${the_module}" STREQUAL "opencv_world")
+      AND (BUILD_SHARED_LIBS AND NOT "x${OPENCV_MODULE_TYPE}" STREQUAL "xSTATIC")
+      AND NOT OPENCV_SKIP_DLLMAIN_GENERATION
+  )
+      set(_DLLMAIN_FILE "${CMAKE_CURRENT_BINARY_DIR}/${the_module}_main.cpp")
+      configure_file("${OpenCV_SOURCE_DIR}/cmake/templates/dllmain.cpp.in" "${_DLLMAIN_FILE}" @ONLY)
+  endif()
 
   source_group("Include" FILES "${OPENCV_CONFIG_FILE_INCLUDE_DIR}/cvconfig.h" "${OPENCV_CONFIG_FILE_INCLUDE_DIR}/opencv2/opencv_modules.hpp")
   source_group("Src" FILES "${${the_module}_pch}")
@@ -918,6 +925,7 @@ macro(_ocv_create_module)
     "${OPENCV_CONFIG_FILE_INCLUDE_DIR}/cvconfig.h" "${OPENCV_CONFIG_FILE_INCLUDE_DIR}/opencv2/opencv_modules.hpp"
     ${${the_module}_pch}
     ${_VS_VERSION_FILE}
+    ${_DLLMAIN_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}

cmake/templates/cvconfig.h.in

@@ -244,5 +244,7 @@
 /* OpenCV trace utilities */
 #cmakedefine OPENCV_TRACE
 
+/* Library QR-code decoding */
+#cmakedefine HAVE_QUIRC
 
 #endif // OPENCV_CVCONFIG_H_INCLUDED

cmake/templates/dllmain.cpp.in

+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef _WIN32
+#error "Build configuration error"
+#endif
+#ifndef CVAPI_EXPORTS
+#error "Build configuration error"
+#endif
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+#define OPENCV_MODULE_S "@the_module@"
+
+namespace cv {
+extern __declspec(dllimport) bool __termination;  // Details: #12750
+}
+
+extern "C"
+BOOL WINAPI DllMain(HINSTANCE, DWORD fdwReason, LPVOID lpReserved);
+
+extern "C"
+BOOL WINAPI DllMain(HINSTANCE, DWORD fdwReason, LPVOID lpReserved)
+{
+    if (fdwReason == DLL_THREAD_DETACH || fdwReason == DLL_PROCESS_DETACH)
+    {
+        if (lpReserved != NULL) // called after ExitProcess() call
+        {
+            //printf("OpenCV: terminating: " OPENCV_MODULE_S "\n");
+            cv::__termination = true;
+        }
+    }
+    return TRUE;
+}

modules/core/include/opencv2/core/hal/intrin_sse.hpp

@@ -472,6 +472,9 @@ void v_rshr_pack_store(ushort* ptr, const v_uint32x4& a)
 
 inline v_uint16x8 v_pack_u(const v_int32x4& a, const v_int32x4& b)
 {
+#if CV_SSE4_1
+    return v_uint16x8(_mm_packus_epi32(a.val, b.val));
+#else
     __m128i delta32 = _mm_set1_epi32(32768);
 
     // preliminary saturate negative values to zero
@@ -480,34 +483,51 @@ inline v_uint16x8 v_pack_u(const v_int32x4& a, const v_int32x4& b)
 
     __m128i r = _mm_packs_epi32(_mm_sub_epi32(a1, delta32), _mm_sub_epi32(b1, delta32));
     return v_uint16x8(_mm_sub_epi16(r, _mm_set1_epi16(-32768)));
+#endif
 }
 
 inline void v_pack_u_store(ushort* ptr, const v_int32x4& a)
 {
+#if CV_SSE4_1
+    _mm_storel_epi64((__m128i*)ptr, _mm_packus_epi32(a.val, a.val));
+#else
     __m128i delta32 = _mm_set1_epi32(32768);
     __m128i a1 = _mm_sub_epi32(a.val, delta32);
     __m128i r = _mm_sub_epi16(_mm_packs_epi32(a1, a1), _mm_set1_epi16(-32768));
     _mm_storel_epi64((__m128i*)ptr, r);
+#endif
 }
 
 template<int n> inline
 v_uint16x8 v_rshr_pack_u(const v_int32x4& a, const v_int32x4& b)
 {
+#if CV_SSE4_1
+    __m128i delta = _mm_set1_epi32(1 << (n - 1));
+    return v_uint16x8(_mm_packus_epi32(_mm_srai_epi32(_mm_add_epi32(a.val, delta), n),
+                                       _mm_srai_epi32(_mm_add_epi32(b.val, delta), n)));
+#else
     __m128i delta = _mm_set1_epi32(1 << (n-1)), delta32 = _mm_set1_epi32(32768);
     __m128i a1 = _mm_sub_epi32(_mm_srai_epi32(_mm_add_epi32(a.val, delta), n), delta32);
     __m128i a2 = _mm_sub_epi16(_mm_packs_epi32(a1, a1), _mm_set1_epi16(-32768));
     __m128i b1 = _mm_sub_epi32(_mm_srai_epi32(_mm_add_epi32(b.val, delta), n), delta32);
     __m128i b2 = _mm_sub_epi16(_mm_packs_epi32(b1, b1), _mm_set1_epi16(-32768));
     return v_uint16x8(_mm_unpacklo_epi64(a2, b2));
+#endif
 }
 
 template<int n> inline
 void v_rshr_pack_u_store(ushort* ptr, const v_int32x4& a)
 {
+#if CV_SSE4_1
+    __m128i delta = _mm_set1_epi32(1 << (n - 1));
+    __m128i a1 = _mm_srai_epi32(_mm_add_epi32(a.val, delta), n);
+    _mm_storel_epi64((__m128i*)ptr, _mm_packus_epi32(a1, a1));
+#else
     __m128i delta = _mm_set1_epi32(1 << (n-1)), delta32 = _mm_set1_epi32(32768);
     __m128i a1 = _mm_sub_epi32(_mm_srai_epi32(_mm_add_epi32(a.val, delta), n), delta32);
     __m128i a2 = _mm_sub_epi16(_mm_packs_epi32(a1, a1), _mm_set1_epi16(-32768));
     _mm_storel_epi64((__m128i*)ptr, a2);
+#endif
 }
 
 inline v_int16x8 v_pack(const v_int32x4& a, const v_int32x4& b)

modules/core/src/ocl.cpp

@@ -4776,6 +4776,10 @@ public:
 
     void deallocate_(UMatData* u) const
     {
+#ifdef _WIN32
+        if (cv::__termination)  // process is not in consistent state (after ExitProcess call) and terminating
+            return;             // avoid any OpenCL calls
+#endif
         if(u->tempUMat())
         {
             CV_Assert(u->origdata);

modules/core/src/parallel.cpp

@@ -447,7 +447,16 @@ static int numThreads = -1;
 #elif defined HAVE_HPX
 // nothing for HPX
 #elif defined HAVE_OPENMP
-static int numThreadsMax = omp_get_max_threads();
+static inline int _initMaxThreads()
+{
+    int maxThreads = omp_get_max_threads();
+    if (!utils::getConfigurationParameterBool("OPENCV_FOR_OPENMP_DYNAMIC_DISABLE", false))
+    {
+        omp_set_dynamic(maxThreads);
+    }
+    return numThreads;
+}
+static int numThreadsMax = _initMaxThreads();
 #elif defined HAVE_GCD
 // nothing for GCD
 #elif defined WINRT

modules/core/src/precomp.hpp

@@ -298,8 +298,9 @@ TLSData<CoreTLSData>& getCoreTlsData();
 #define CL_RUNTIME_EXPORT
 #endif
 
-extern bool __termination; // skip some cleanups, because process is terminating
-                           // (for example, if ExitProcess() was already called)
+extern CV_EXPORTS
+bool __termination;  // skip some cleanups, because process is terminating
+                     // (for example, if ExitProcess() was already called)
 
 cv::Mutex& getInitializationMutex();
 

modules/objdetect/CMakeLists.txt

 set(the_description "Object Detection")
-ocv_define_module(objdetect opencv_core opencv_imgproc WRAP java python js)
+ocv_define_module(objdetect opencv_core opencv_imgproc opencv_calib3d WRAP java python js)
+
+if(HAVE_QUIRC)
+    get_property(QUIRC_INCLUDE GLOBAL PROPERTY QUIRC_INCLUDE_DIR)
+    ocv_include_directories(${QUIRC_INCLUDE})
+    ocv_target_link_libraries(${PROJECT_NAME} quirc)
+endif()

modules/objdetect/include/opencv2/objdetect.hpp

@@ -690,6 +690,13 @@ protected:
     */
 CV_EXPORTS bool detectQRCode(InputArray in, std::vector<Point> &points, double eps_x = 0.2, double eps_y = 0.1);
 
+/** @brief Decode QR code in image and return text that is encrypted in QR code.
+    @param in  Matrix of the type CV_8UC1 containing an image where QR code are detected.
+    @param points Input vector of vertices of a quadrangle of minimal area that describes QR code.
+    @param decoded_info String information that is encrypted in QR code.
+    @param straight_qrcode Matrix of the type CV_8UC1 containing an binary straight QR code.
+    */
+CV_EXPORTS bool decodeQRCode(InputArray in, InputArray points, std::string &decoded_info, OutputArray straight_qrcode = noArray());
 //! @} objdetect
 
 }

modules/objdetect/test/test_qrcode.cpp

@@ -4,19 +4,15 @@
 
 #include "test_precomp.hpp"
 
-
 namespace opencv_test { namespace {
 
 std::string qrcode_images_name[] = {
-    // "20110817_030.jpg",
-    "20110817_048.jpg",
-    "img_20120226_161648.jpg",
-    "img_2714.jpg",
-    "img_2716.jpg",
-    "img_3011.jpg",
-    "img_3029.jpg",
-    "img_3070.jpg",
-    "qr_test_030.jpg"
+  "version_1_down.jpg", "version_1_left.jpg", "version_1_right.jpg", "version_1_up.jpg", "version_1_top.jpg",
+  "version_2_down.jpg", "version_2_left.jpg", "version_2_right.jpg", "version_2_up.jpg", "version_2_top.jpg",
+  "version_3_down.jpg", "version_3_left.jpg", "version_3_right.jpg", "version_3_up.jpg", "version_3_top.jpg",
+  "version_4_down.jpg", "version_4_left.jpg", "version_4_right.jpg", "version_4_up.jpg", "version_4_top.jpg",
+  "version_5_down.jpg", "version_5_left.jpg", "version_5_right.jpg", "version_5_up.jpg", "version_5_top.jpg",
+  "russian.jpg", "kanji.jpg", "link_github_ocv.jpg", "link_ocv.jpg", "link_wiki_cv.jpg"
 };
 
 // #define UPDATE_QRCODE_TEST_DATA
@@ -35,15 +31,21 @@ TEST(Objdetect_QRCode, generate_test_data)
         file_config << "{:" << "image_name" << qrcode_images_name[i];
         std::string image_path = findDataFile(root + qrcode_images_name[i]);
         std::vector<Point> corners;
-        Mat src = imread(image_path, IMREAD_GRAYSCALE);
+        Mat src = imread(image_path, IMREAD_GRAYSCALE), straight_barcode;
+        std::string decoded_info;
         ASSERT_FALSE(src.empty()) << "Can't read image: " << image_path;
         EXPECT_TRUE(detectQRCode(src, corners));
+#ifdef HAVE_QUIRC
+        EXPECT_TRUE(decodeQRCode(src, corners, decoded_info, straight_barcode));
+#endif
         file_config << "x" << "[:";
         for (size_t j = 0; j < corners.size(); j++) { file_config << corners[j].x; }
         file_config << "]";
         file_config << "y" << "[:";
         for (size_t j = 0; j < corners.size(); j++) { file_config << corners[j].y; }
-        file_config << "]" << "}";
+        file_config << "]";
+        file_config << "info" << decoded_info;
+        file_config << "}";
     }
     file_config << "]";
     file_config.release();
@@ -59,11 +61,15 @@ TEST_P(Objdetect_QRCode, regression)
     const int pixels_error = 3;
 
     std::string image_path = findDataFile(root + name_current_image);
-    Mat src = imread(image_path, IMREAD_GRAYSCALE);
+    Mat src = imread(image_path, IMREAD_GRAYSCALE), straight_barcode;
     ASSERT_FALSE(src.empty()) << "Can't read image: " << image_path;
 
     std::vector<Point> corners;
+    std::string decoded_info;
     ASSERT_TRUE(detectQRCode(src, corners));
+#ifdef HAVE_QUIRC
+    ASSERT_TRUE(decodeQRCode(src, corners, decoded_info, straight_barcode));
+#endif
 
     const std::string dataset_config = findDataFile(root + "dataset_config.json", false);
     FileStorage file_config(dataset_config, FileStorage::READ);
@@ -86,6 +92,12 @@ TEST_P(Objdetect_QRCode, regression)
                     EXPECT_NEAR(x, corners[i].x, pixels_error);
                     EXPECT_NEAR(y, corners[i].y, pixels_error);
                 }
+
+#ifdef HAVE_QUIRC
+                std::string original_info = config["info"];
+                EXPECT_EQ(decoded_info, original_info);
+#endif
+
                 return; // done
             }
         }
@@ -103,9 +115,14 @@ INSTANTIATE_TEST_CASE_P(/**/, Objdetect_QRCode, testing::ValuesIn(qrcode_images_
 
 TEST(Objdetect_QRCode_basic, not_found_qrcode)
 {
-    std::vector<Point> corners;
+    std::vector<Point> corners, straight_barcode;
+    std::string decoded_info;
     Mat zero_image = Mat::zeros(256, 256, CV_8UC1);
     EXPECT_FALSE(detectQRCode(zero_image, corners));
+#ifdef HAVE_QUIRC
+    corners = std::vector<Point>(4);
+    EXPECT_FALSE(decodeQRCode(zero_image, corners, decoded_info, straight_barcode));
+#endif
 }
 
 

modules/stitching/src/matchers.cpp

@@ -52,6 +52,10 @@ using namespace cv::cuda;
 #include "opencv2/xfeatures2d.hpp"
 using xfeatures2d::SURF;
 using xfeatures2d::SIFT;
+#else
+#  if defined(_MSC_VER)
+#    pragma warning(disable:4702)  // unreachable code
+#  endif
 #endif
 
 #ifdef HAVE_OPENCV_CUDAIMGPROC