dnn: prevent unloading of InferenceEngine plugins

Support lrn with SPATIAL_NRM
MVN support through nGraph
2026-07-25 21:33:04 +04:00 · 2020-01-22 18:46:00 +03:00 · 2020-01-21 12:49:58 +03:00 · 2020-01-17 12:11:45 +03:00 · 2020-01-15 20:01:53 +03:00 · 2020-01-15 17:52:24 +03:00
701 changed files with 10782 additions and 26704 deletions
@@ -1,8 +1,23 @@
+<!--
+If you have a question rather than reporting a bug please go to http://answers.opencv.org where you get much faster responses.
+If you need further assistance please read [How To Contribute](https://github.com/opencv/opencv/wiki/How_to_contribute).
+
+Please:
+
+* Read the documentation to test with the latest developer build.
+* Check if other person has already created the same issue to avoid duplicates. You can comment on it if there already is an issue.
+* Try to be as detailed as possible in your report.
+* Report only one problem per created issue.
+
+
+This is a template helping you to create an issue which can be processed as quickly as possible. This is the bug reporting section for the OpenCV library.
+-->
+
 ##### System information (version)
 <!-- Example
- OpenCV => 4.2
+- OpenCV => 3.1
 - Operating System / Platform => Windows 64 Bit
- Compiler => Visual Studio 2017
+- Compiler => Visual Studio 2015
 -->

 - OpenCV => :grey_question:
@@ -21,42 +36,3 @@
    ```
 or attach as .txt or .zip file
 -->
-
-##### Issue submission checklist
-
- - [ ] I report the issue, it's not a question
-   <!--
-   OpenCV team works with answers.opencv.org, Stack Overflow and other communities
-   to discuss problems. Tickets with question without real issue statement will be
-   closed.
-   -->
- - [ ] I checked the problem with documentation, FAQ, open issues,
-       answers.opencv.org, Stack Overflow, etc and have not found solution
-   <!--
-   Places to check:
-   * OpenCV documentation: https://docs.opencv.org
-   * FAQ page: https://github.com/opencv/opencv/wiki/FAQ
-   * OpenCV forum: https://answers.opencv.org
-   * OpenCV issue tracker: https://github.com/opencv/opencv/issues?q=is%3Aissue
-   * Stack Overflow branch: https://stackoverflow.com/questions/tagged/opencv
-   -->
- - [ ] I updated to latest OpenCV version and the issue is still there
-   <!--
-   master branch for OpenCV 4.x and 3.4 branch for OpenCV 3.x releases.
-   OpenCV team supports only latest release for each branch.
-   The ticket is closed, if the problem is not reproduced with modern version.
-   -->
- - [ ] There is reproducer code and related data files: videos, images, onnx, etc
-   <!--
-   The best reproducer -- test case for OpenCV that we can add to the library.
-   Recommendations for media files and binary files:
-   * Try to reproduce the issue with images and videos in opencv_extra repository
-     to reduce attachment size
-   * Use PNG for images, if you report some CV related bug, but not image reader
-     issue
-   * Attach the image as archite to the ticket, if you report some reader issue.
-     Image hosting services compress images and it breaks the repro code.
-   * Provide ONNX file for some public model or ONNX file with with random weights,
-     if you report ONNX parsing or handling issue. Architecture details diagram
-     from netron tool can be very useful too. See https://lutzroeder.github.io/netron/
-   -->
@@ -1,11 +1,9 @@
-### Pull Request Readiness Checklist
+<!-- Please use this line to close one or multiple issues when this pullrequest gets merged
+You can add another line right under the first one:
+resolves #1234
+resolves #1235
+-->

-See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request
+### This pullrequest changes

- [ ] I agree to contribute to the project under OpenCV (BSD) License.
- [ ] To the best of my knowledge, the proposed patch is not based on a code under GPL or other license that is incompatible with OpenCV
- [ ] The PR is proposed to proper branch
- [ ] There is reference to original bug report and related work
- [ ] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
-      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake
+<!-- Please describe what your pullrequest is changing -->
@@ -23,4 +23,3 @@ bin/
 *.tlog
 build
 node_modules
-CMakeSettings.json
@@ -20,11 +20,8 @@ if(CMAKE_COMPILER_IS_GNUCC)
    # - matchTemplate about 5-10%
    # - goodFeaturesToTrack 10-20%
    # - cornerHarris 30% for some cases
-    if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "10.0.0")
-        set_source_files_properties(${carotene_sources} COMPILE_FLAGS "--param ipcp-unit-growth=100000 --param inline-unit-growth=100000 --param large-stack-frame-growth=5000")
-    else()
-        set_source_files_properties(${carotene_sources} COMPILE_FLAGS "--param ipa-cp-unit-growth=100000 --param inline-unit-growth=100000 --param large-stack-frame-growth=5000")
-    endif()
+
+    set_source_files_properties(${carotene_sources} COMPILE_FLAGS "--param ipcp-unit-growth=100000 --param inline-unit-growth=100000 --param large-stack-frame-growth=5000")
 endif()

 add_library(carotene_objs OBJECT
@@ -60,6 +60,22 @@ function(compile_carotene)
  endif()

  add_subdirectory("${CAROTENE_DIR}" "${CMAKE_CURRENT_BINARY_DIR}/carotene")
+
+  if(ARM OR AARCH64)
+    if(CMAKE_BUILD_TYPE)
+      set(CMAKE_TRY_COMPILE_CONFIGURATION ${CMAKE_BUILD_TYPE})
+    endif()
+    check_cxx_compiler_flag("-mfpu=neon" CXX_HAS_MFPU_NEON)
+    check_c_compiler_flag("-mfpu=neon" C_HAS_MFPU_NEON)
+    if(${CXX_HAS_MFPU_NEON} AND ${C_HAS_MFPU_NEON} AND NOT "${CMAKE_CXX_FLAGS} " MATCHES "-mfpu=neon[^ ]*")
+      get_target_property(old_flags "carotene_objs" COMPILE_FLAGS)
+      if(old_flags)
+        set_target_properties("carotene_objs" PROPERTIES COMPILE_FLAGS "${old_flags} -mfpu=neon")
+      else()
+        set_target_properties("carotene_objs" PROPERTIES COMPILE_FLAGS "-mfpu=neon")
+      endif()
+    endif()
+  endif()
 endfunction()

 compile_carotene()
@@ -74,11 +90,7 @@ set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS ${carotene_defs})
    #   matchTemplate about 5-10%
    #   goodFeaturesToTrack 10-20%
    #   cornerHarris 30% for some cases
-    if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "10.0.0")
-      set_source_files_properties(impl.cpp $<TARGET_OBJECTS:carotene_objs> COMPILE_FLAGS "--param ipcp-unit-growth=100000 --param inline-unit-growth=100000 --param large-stack-frame-growth=5000")
-    else()
-      set_source_files_properties(impl.cpp $<TARGET_OBJECTS:carotene_objs> COMPILE_FLAGS "--param ipa-cp-unit-growth=100000 --param inline-unit-growth=100000 --param large-stack-frame-growth=5000")
-    endif()
+    set_source_files_properties(impl.cpp $<TARGET_OBJECTS:carotene_objs> COMPILE_FLAGS "--param ipcp-unit-growth=100000 --param inline-unit-growth=100000 --param large-stack-frame-growth=5000")
 #    set_source_files_properties(impl.cpp $<TARGET_OBJECTS:carotene_objs> COMPILE_FLAGS "--param ipcp-unit-growth=100000 --param inline-unit-growth=100000 --param large-stack-frame-growth=5000")
  endif()

@@ -1,8 +1,8 @@
-# Binaries branch name: ffmpeg/master_20200311
-# Binaries were created for OpenCV: 850414a501d5e6dba111c92d73fdd05794c7061d
-ocv_update(FFMPEG_BINARIES_COMMIT "3d2e97081683265950316c65a52c2e8858ffba1b")
-ocv_update(FFMPEG_FILE_HASH_BIN32 "3b094c37d270a30f0b20a0bc8d3ecafb")
-ocv_update(FFMPEG_FILE_HASH_BIN64 "388ee23a7ca44eef2344e265fafd5940")
+# Binaries branch name: ffmpeg/master_20191119
+# Binaries were created for OpenCV: 318cba4ce37319ba0b0870aab384d5dc066bb124
+ocv_update(FFMPEG_BINARIES_COMMIT "a66a24e9f410ae05da4baeeb8b451912664ce49c")
+ocv_update(FFMPEG_FILE_HASH_BIN32 "5de6044cad9398549e57bc46fc13908d")
+ocv_update(FFMPEG_FILE_HASH_BIN64 "55c0bc8ad27db00116fabf06508de196")
 ocv_update(FFMPEG_FILE_HASH_CMAKE "ad57c038ba34b868277ccbe6dd0f9602")

 function(download_win_ffmpeg script_var)
@@ -2,32 +2,37 @@ function(download_ippicv root_var)
  set(${root_var} "" PARENT_SCOPE)

  # Commit SHA in the opencv_3rdparty repo
-  set(IPPICV_COMMIT "a56b6ac6f030c312b2dce17430eef13aed9af274")
+  set(IPPICV_COMMIT "32e315a5b106a7b89dbed51c28f8120a48b368b4")
  # Define actual ICV versions
  if(APPLE)
    set(OPENCV_ICV_PLATFORM "macosx")
    set(OPENCV_ICV_PACKAGE_SUBDIR "ippicv_mac")
-    set(OPENCV_ICV_NAME "ippicv_2020_mac_intel64_20191018_general.tgz")
-    set(OPENCV_ICV_HASH "1c3d675c2a2395d094d523024896e01b")
+    if(X86_64)
+      set(OPENCV_ICV_NAME "ippicv_2019_mac_intel64_general_20180723.tgz")
+      set(OPENCV_ICV_HASH "fe6b2bb75ae0e3f19ad3ae1a31dfa4a2")
+    else()
+      set(OPENCV_ICV_NAME "ippicv_2019_mac_ia32_general_20180723.tgz")
+      set(OPENCV_ICV_HASH "b5dfa78c87eb75c64470cbe5ec876f4f")
+    endif()
  elseif((UNIX AND NOT ANDROID) OR (UNIX AND ANDROID_ABI MATCHES "x86"))
    set(OPENCV_ICV_PLATFORM "linux")
    set(OPENCV_ICV_PACKAGE_SUBDIR "ippicv_lnx")
    if(X86_64)
-      set(OPENCV_ICV_NAME "ippicv_2020_lnx_intel64_20191018_general.tgz")
-      set(OPENCV_ICV_HASH "7421de0095c7a39162ae13a6098782f9")
+      set(OPENCV_ICV_NAME "ippicv_2019_lnx_intel64_general_20180723.tgz")
+      set(OPENCV_ICV_HASH "c0bd78adb4156bbf552c1dfe90599607")
    else()
-      set(OPENCV_ICV_NAME "ippicv_2020_lnx_ia32_20191018_general.tgz")
-      set(OPENCV_ICV_HASH "ad189a940fb60eb71f291321322fe3e8")
+      set(OPENCV_ICV_NAME "ippicv_2019_lnx_ia32_general_20180723.tgz")
+      set(OPENCV_ICV_HASH "4f38432c30bfd6423164b7a24bbc98a0")
    endif()
  elseif(WIN32 AND NOT ARM)
    set(OPENCV_ICV_PLATFORM "windows")
    set(OPENCV_ICV_PACKAGE_SUBDIR "ippicv_win")
    if(X86_64)
-      set(OPENCV_ICV_NAME "ippicv_2020_win_intel64_20191018_general.zip")
-      set(OPENCV_ICV_HASH "879741a7946b814455eee6c6ffde2984")
+      set(OPENCV_ICV_NAME "ippicv_2019_win_intel64_20180723_general.zip")
+      set(OPENCV_ICV_HASH "1d222685246896fe089f88b8858e4b2f")
    else()
-      set(OPENCV_ICV_NAME "ippicv_2020_win_ia32_20191018_general.zip")
-      set(OPENCV_ICV_HASH "cd39bdf0c2e1cac9a61101dad7a2413e")
+      set(OPENCV_ICV_NAME "ippicv_2019_win_ia32_20180723_general.zip")
+      set(OPENCV_ICV_HASH "0157251a2eb9cd63a3ebc7eed0f3e59e")
    endif()
  else()
    return()
@@ -4,9 +4,9 @@ ocv_warnings_disable(CMAKE_C_FLAGS -Wunused-parameter -Wsign-compare -Wshorten-6

 set(VERSION_MAJOR 2)
 set(VERSION_MINOR 0)
-set(VERSION_REVISION 4)
+set(VERSION_REVISION 2)
 set(VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_REVISION})
-set(LIBJPEG_TURBO_VERSION_NUMBER 2000004)
+set(LIBJPEG_TURBO_VERSION_NUMBER 2000002)

 string(TIMESTAMP BUILD "opencv-${OPENCV_VERSION}-libjpeg-turbo")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
@@ -1,14 +1,14 @@
 Background
 ==========

-libjpeg-turbo is a JPEG image codec that uses SIMD instructions to accelerate
-baseline JPEG compression and decompression on x86, x86-64, ARM, PowerPC, and
-MIPS systems, as well as progressive JPEG compression on x86 and x86-64
-systems.  On such systems, libjpeg-turbo is generally 2-6x as fast as libjpeg,
-all else being equal.  On other types of systems, libjpeg-turbo can still
-outperform libjpeg by a significant amount, by virtue of its highly-optimized
-Huffman coding routines.  In many cases, the performance of libjpeg-turbo
-rivals that of proprietary high-speed JPEG codecs.
+libjpeg-turbo is a JPEG image codec that uses SIMD instructions (MMX, SSE2,
+AVX2, NEON, AltiVec) to accelerate baseline JPEG compression and decompression
+on x86, x86-64, ARM, and PowerPC systems, as well as progressive JPEG
+compression on x86 and x86-64 systems.  On such systems, libjpeg-turbo is
+generally 2-6x as fast as libjpeg, all else being equal.  On other types of
+systems, libjpeg-turbo can still outperform libjpeg by a significant amount, by
+virtue of its highly-optimized Huffman coding routines.  In many cases, the
+performance of libjpeg-turbo rivals that of proprietary high-speed JPEG codecs.

 libjpeg-turbo implements both the traditional libjpeg API as well as the less
 powerful but more straightforward TurboJPEG API.  libjpeg-turbo also features
@@ -135,24 +135,25 @@ without recompiling.  libjpeg-turbo does not claim to support all of the
 libjpeg v7+ features, nor to produce identical output to libjpeg v7+ in all
 cases (see below.)

-By passing an argument of `-DWITH_JPEG7=1` or `-DWITH_JPEG8=1` to `cmake`, you
-can build a version of libjpeg-turbo that emulates the libjpeg v7 or v8 ABI, so
-that programs that are built against libjpeg v7 or v8 can be run with
-libjpeg-turbo.  The following section describes which libjpeg v7+ features are
-supported and which aren't.
+By passing an argument of `--with-jpeg7` or `--with-jpeg8` to `configure`, or
+an argument of `-DWITH_JPEG7=1` or `-DWITH_JPEG8=1` to `cmake`, you can build a
+version of libjpeg-turbo that emulates the libjpeg v7 or v8 ABI, so that
+programs that are built against libjpeg v7 or v8 can be run with libjpeg-turbo.
+The following section describes which libjpeg v7+ features are supported and
+which aren't.

 ### Support for libjpeg v7 and v8 Features

 #### Fully supported

- **libjpeg API: IDCT scaling extensions in decompressor**<br>
+- **libjpeg: IDCT scaling extensions in decompressor**<br>
  libjpeg-turbo supports IDCT scaling with scaling factors of 1/8, 1/4, 3/8,
  1/2, 5/8, 3/4, 7/8, 9/8, 5/4, 11/8, 3/2, 13/8, 7/4, 15/8, and 2/1 (only 1/4
  and 1/2 are SIMD-accelerated.)

- **libjpeg API: Arithmetic coding**
+- **libjpeg: Arithmetic coding**

- **libjpeg API: In-memory source and destination managers**<br>
+- **libjpeg: In-memory source and destination managers**<br>
  See notes below.

 - **cjpeg: Separate quality settings for luminance and chrominance**<br>
@@ -184,14 +185,14 @@ means of quality improvement.  The reader is invited to peruse the research at
 but it is the general belief of our project that these features have not
 demonstrated sufficient usefulness to justify inclusion in libjpeg-turbo.

- **libjpeg API: DCT scaling in compressor**<br>
+- **libjpeg: DCT scaling in compressor**<br>
  `cinfo.scale_num` and `cinfo.scale_denom` are silently ignored.
  There is no technical reason why DCT scaling could not be supported when
  emulating the libjpeg v7+ API/ABI, but without the SmartScale extension (see
  below), only scaling factors of 1/2, 8/15, 4/7, 8/13, 2/3, 8/11, 4/5, and
  8/9 would be available, which is of limited usefulness.

- **libjpeg API: SmartScale**<br>
+- **libjpeg: SmartScale**<br>
  `cinfo.block_size` is silently ignored.
  SmartScale is an extension to the JPEG format that allows for DCT block
  sizes other than 8x8.  Providing support for this new format would be
@@ -204,7 +205,7 @@ demonstrated sufficient usefulness to justify inclusion in libjpeg-turbo.
  interest in providing this feature would be as a means of supporting
  additional DCT scaling factors.

- **libjpeg API: Fancy downsampling in compressor**<br>
+- **libjpeg: Fancy downsampling in compressor**<br>
  `cinfo.do_fancy_downsampling` is silently ignored.
  This requires the DCT scaling feature, which is not supported.

@@ -246,14 +247,15 @@ don't, and it allows those functions to be provided in the "official"
 libjpeg-turbo binaries.

 Those who are concerned about maintaining strict conformance with the libjpeg
-v6b or v7 API can pass an argument of `-DWITH_MEM_SRCDST=0` to `cmake` prior to
-building libjpeg-turbo.  This will restore the pre-1.3 behavior, in which
+v6b or v7 API can pass an argument of `--without-mem-srcdst` to `configure` or
+an argument of `-DWITH_MEM_SRCDST=0` to `cmake` prior to building
+libjpeg-turbo.  This will restore the pre-1.3 behavior, in which
 `jpeg_mem_src()` and `jpeg_mem_dest()` are only included when emulating the
 libjpeg v8 API/ABI.

 On Un*x systems, including the in-memory source/destination managers changes
-the dynamic library version from 62.2.0 to 62.3.0 if using libjpeg v6b API/ABI
-emulation and from 7.2.0 to 7.3.0 if using libjpeg v7 API/ABI emulation.
+the dynamic library version from 62.1.0 to 62.2.0 if using libjpeg v6b API/ABI
+emulation and from 7.1.0 to 7.2.0 if using libjpeg v7 API/ABI emulation.

 Note that, on most Un*x systems, the dynamic linker will not look for a
 function in a library until that function is actually used.  Thus, if a program
@@ -329,7 +331,7 @@ in a way that makes the rest of the libjpeg infrastructure happy, so it is
 necessary to use the slow Huffman decoder when decompressing a JPEG image that
 has restart markers.  This can cause the decompression performance to drop by
 as much as 20%, but the performance will still be much greater than that of
-libjpeg.  Many consumer packages, such as Photoshop, use restart markers when
+libjpeg.  Many consumer packages, such as PhotoShop, use restart markers when
 generating JPEG images, so images generated by those programs will experience
 this issue.

@@ -342,15 +344,3 @@ quality of 98-100.  Thus, libjpeg-turbo must use the non-SIMD quantization
 function in those cases.  This causes performance to drop by as much as 40%.
 It is therefore strongly advised that you use the slow integer forward DCT
 whenever encoding images with a JPEG quality of 98 or higher.
-
-
-Memory Debugger Pitfalls
-========================
-
-Valgrind and Memory Sanitizer (MSan) can generate false positives
-(specifically, incorrect reports of uninitialized memory accesses) when used
-with libjpeg-turbo's SIMD extensions.  It is generally recommended that the
-SIMD extensions be disabled, either by passing an argument of `-DWITH_SIMD=0`
-to `cmake` when configuring the build or by setting the environment variable
-`JSIMD_FORCENONE` to `1` at run time, when testing libjpeg-turbo with Valgrind,
-MSan, or other memory debuggers.
@@ -4,7 +4,7 @@
 * This file was part of the Independent JPEG Group's software:
 * Copyright (C) 1991-1997, Thomas G. Lane.
 * libjpeg-turbo Modifications:
- * Copyright (C) 2009-2011, 2014-2016, 2018-2019, D. R. Commander.
+ * Copyright (C) 2009-2011, 2014-2016, 2018, D. R. Commander.
 * Copyright (C) 2015, Matthieu Darbois.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
@@ -43,8 +43,8 @@
 */

 /* NOTE: Both GCC and Clang define __GNUC__ */
-#if defined(__GNUC__) && (defined(__arm__) || defined(__aarch64__))
-#if !defined(__thumb__) || defined(__thumb2__)
+#if defined __GNUC__ && (defined __arm__ || defined __aarch64__)
+#if !defined __thumb__ || defined __thumb2__
 #define USE_CLZ_INTRINSIC
 #endif
 #endif
@@ -356,8 +356,6 @@ dump_buffer(working_state *state)
  put_buffer = (put_buffer << size) | code; \
 }

-#if SIZEOF_SIZE_T != 8 && !defined(_WIN64)
-
 #define CHECKBUF15() { \
  if (put_bits > 15) { \
    EMIT_BYTE() \
@@ -365,8 +363,6 @@ dump_buffer(working_state *state)
  } \
 }

-#endif
-
 #define CHECKBUF31() { \
  if (put_bits > 31) { \
    EMIT_BYTE() \
@@ -432,7 +428,7 @@ dump_buffer(working_state *state)
 * scanning order-- 1, 8, 16, etc.), then this will produce an encoded block
 * larger than 200 bytes.
 */
-#define BUFSIZE  (DCTSIZE2 * 8)
+#define BUFSIZE  (DCTSIZE2 * 4)

 #define LOAD_BUFFER() { \
  if (state->free_in_buffer < BUFSIZE) { \
@@ -492,8 +492,8 @@ prepare_for_pass(j_compress_ptr cinfo)
     */
    master->pass_type = output_pass;
    master->pass_number++;
-#endif
    /*FALLTHROUGH*/
+#endif
  case output_pass:
    /* Do a data-output pass. */
    /* We need not repeat per-scan setup if prior optimization pass did it. */
@@ -52,8 +52,8 @@
 */

 /* NOTE: Both GCC and Clang define __GNUC__ */
-#if defined(__GNUC__) && (defined(__arm__) || defined(__aarch64__))
-#if !defined(__thumb__) || defined(__thumb2__)
+#if defined __GNUC__ && (defined __arm__ || defined __aarch64__)
+#if !defined __thumb__ || defined __thumb2__
 #define USE_CLZ_INTRINSIC
 #endif
 #endif
@@ -4,7 +4,7 @@
 * This file was part of the Independent JPEG Group's software:
 * Copyright (C) 1991-1997, Thomas G. Lane.
 * libjpeg-turbo Modifications:
- * Copyright (C) 2009-2011, 2016, 2018-2019, D. R. Commander.
+ * Copyright (C) 2009-2011, 2016, 2018, D. R. Commander.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
 *
@@ -589,11 +589,7 @@ decode_mcu_slow(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
    if (entropy->dc_needed[blkn]) {
      /* Convert DC difference to actual value, update last_dc_val */
      int ci = cinfo->MCU_membership[blkn];
-      /* This is really just
-       *   s += state.last_dc_val[ci];
-       * It is written this way in order to shut up UBSan.
-       */
-      s = (int)((unsigned int)s + (unsigned int)state.last_dc_val[ci]);
+      s += state.last_dc_val[ci];
      state.last_dc_val[ci] = s;
      if (block) {
        /* Output the DC coefficient (assumes jpeg_natural_order[0] = 0) */
@@ -688,7 +684,7 @@ decode_mcu_fast(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)

    if (entropy->dc_needed[blkn]) {
      int ci = cinfo->MCU_membership[blkn];
-      s = (int)((unsigned int)s + (unsigned int)state.last_dc_val[ci]);
+      s += state.last_dc_val[ci];
      state.last_dc_val[ci] = s;
      if (block)
        (*block)[0] = (JCOEF)s;
@@ -429,6 +429,8 @@ h2v2_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 #define PACK_TWO_PIXELS_LE(l, r)    ((r << 16) | l)
 #define PACK_TWO_PIXELS_BE(l, r)    ((l << 16) | r)

+#define PACK_NEED_ALIGNMENT(ptr)    (((size_t)(ptr)) & 3)
+
 #define WRITE_TWO_PIXELS_LE(addr, pixels) { \
  ((INT16 *)(addr))[0] = (INT16)(pixels); \
  ((INT16 *)(addr))[1] = (INT16)((pixels) >> 16); \
@@ -8,7 +8,6 @@
 * Copyright (C) 2010, 2015-2016, D. R. Commander.
 * Copyright (C) 2014, MIPS Technologies, Inc., California.
 * Copyright (C) 2015, Google, Inc.
- * Copyright (C) 2019, Arm Limited.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
 *
@@ -316,9 +315,9 @@ h1v2_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
  JSAMPARRAY output_data = *output_data_ptr;
  JSAMPROW inptr0, inptr1, outptr;
 #if BITS_IN_JSAMPLE == 8
-  int thiscolsum, bias;
+  int thiscolsum;
 #else
-  JLONG thiscolsum, bias;
+  JLONG thiscolsum;
 #endif
  JDIMENSION colctr;
  int inrow, outrow, v;
@@ -328,18 +327,15 @@ h1v2_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
    for (v = 0; v < 2; v++) {
      /* inptr0 points to nearest input row, inptr1 points to next nearest */
      inptr0 = input_data[inrow];
-      if (v == 0) {             /* next nearest is row above */
+      if (v == 0)               /* next nearest is row above */
        inptr1 = input_data[inrow - 1];
-        bias = 1;
-      } else {                  /* next nearest is row below */
+      else                      /* next nearest is row below */
        inptr1 = input_data[inrow + 1];
-        bias = 2;
-      }
      outptr = output_data[outrow++];

      for (colctr = 0; colctr < compptr->downsampled_width; colctr++) {
        thiscolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++);
-        *outptr++ = (JSAMPLE)((thiscolsum + bias) >> 2);
+        *outptr++ = (JSAMPLE)((thiscolsum + 1) >> 2);
      }
    }
    inrow++;
@@ -1,7 +1,7 @@
 /*
 * jfdctint.c
 *
- * This file was part of the Independent JPEG Group's software:
+ * This file was part of the Independent JPEG Group's software.
 * Copyright (C) 1991-1996, Thomas G. Lane.
 * libjpeg-turbo Modifications:
 * Copyright (C) 2015, D. R. Commander.
@@ -1,7 +1,7 @@
 /*
 * jidctint.c
 *
- * This file was part of the Independent JPEG Group's software:
+ * This file was part of the Independent JPEG Group's software.
 * Copyright (C) 1991-1998, Thomas G. Lane.
 * Modification developed 2002-2009 by Guido Vollbeding.
 * libjpeg-turbo Modifications:
@@ -1,7 +1,7 @@
 /*
 * jidctred.c
 *
- * This file was part of the Independent JPEG Group's software:
+ * This file was part of the Independent JPEG Group's software.
 * Copyright (C) 1994-1998, Thomas G. Lane.
 * libjpeg-turbo Modifications:
 * Copyright (C) 2015, D. R. Commander.
@@ -1,91 +0,0 @@
-# COPYRIGHT
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# License); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# AS IS BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-# Copyright (c) 2020, OPEN AI LAB
-# Author: qtang@openailab.com or https://github.com/BUG1989
-#         qli@openailab.com
-#         sqfu@openailab.com
-#
-
-SET(TENGINE_COMMIT_VERSION "2f3cd86217f3530c8e4a82f3ed5af14c7a4e3943")
-SET(OCV_TENGINE_DIR "${OpenCV_BINARY_DIR}/3rdparty/libtengine")
-SET(OCV_TENGINE_SOURCE_PATH "${OCV_TENGINE_DIR}/Tengine-${TENGINE_COMMIT_VERSION}")
-
-IF(EXISTS "${OCV_TENGINE_SOURCE_PATH}")
-	MESSAGE(STATUS "Tengine is exist already at: ${OCV_TENGINE_SOURCE_PATH}")
-
-	SET(Tengine_FOUND ON)
-	SET(BUILD_TENGINE ON)
-ELSE()
-	SET(OCV_TENGINE_FILENAME "${TENGINE_COMMIT_VERSION}.zip")#name2
-	SET(OCV_TENGINE_URL "https://github.com/OAID/Tengine/archive/") #url2
-	SET(tengine_md5sum 9124324b6e2b350012e46ae1db4bad7d) #md5sum2
-
-	#MESSAGE(STATUS "**** TENGINE DOWNLOAD BEGIN ****")
-	ocv_download(FILENAME ${OCV_TENGINE_FILENAME}
-						HASH ${tengine_md5sum}
-						URL
-						"${OPENCV_TENGINE_URL}"
-						"$ENV{OPENCV_TENGINE_URL}"
-						"${OCV_TENGINE_URL}"
-						DESTINATION_DIR "${OCV_TENGINE_DIR}"
-						ID TENGINE
-						STATUS res
-						UNPACK RELATIVE_URL)
-
-	if (NOT res)
-		MESSAGE(STATUS "TENGINE DOWNLOAD FAILED. Turning Tengine_FOUND off.")
-		SET(Tengine_FOUND OFF)
-	else ()
-		MESSAGE(STATUS "TENGINE DOWNLOAD success . ")
-
-		SET(Tengine_FOUND ON)
-		SET(BUILD_TENGINE ON)
-	endif()
-ENDIF()
-
-if(BUILD_TENGINE)
-	SET(HAVE_TENGINE 1)
-
-	# android system
-	if(ANDROID)
-	   if(${ANDROID_ABI} STREQUAL "armeabi-v7a")
-			   SET(CONFIG_ARCH_ARM32 ON)
-	   elseif(${ANDROID_ABI} STREQUAL "arm64-v8a")
-			   SET(CONFIG_ARCH_ARM64 ON)
-	   endif()
-	   SET(Tengine_LIB "tengine" CACHE INTERNAL "")
-	else()
-		# linux system
-		if(CMAKE_SYSTEM_PROCESSOR STREQUAL arm)
-			   SET(CONFIG_ARCH_ARM32 ON)
-		elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL aarch64) ## AARCH64
-			   SET(CONFIG_ARCH_ARM64 ON)
-		endif()
-		SET(Tengine_LIB "tengine" CACHE INTERNAL "")
-	endif()
-
-	SET(BUILT_IN_OPENCV ON) ## set for tengine compile discern .
-	SET(Tengine_INCLUDE_DIR  "${OCV_TENGINE_SOURCE_PATH}/core/include" CACHE INTERNAL "")
-	if(EXISTS "${OCV_TENGINE_SOURCE_PATH}/CMakeLists.txt")
-		add_subdirectory("${OCV_TENGINE_SOURCE_PATH}" "${OCV_TENGINE_DIR}/build")
-	else()
-		message(WARNING "TENGINE: Missing 'CMakeLists.txt' in source code package: ${OCV_TENGINE_SOURCE_PATH}")
-		SET(HAVE_TENGINE 1)
-	endif()
-endif()
@@ -126,30 +126,30 @@ endif()
 if(SIZEOF_UNSIGNED_INT EQUAL SIZEOF_SIZE_T)
  set(TIFF_SIZE_T "unsigned int")
  set(TIFF_SIZE_FORMAT "%u")
-  set(TIFF_SSIZE_T "signed int")
-  set(TIFF_SSIZE_FORMAT "%d")
 elseif(SIZEOF_UNSIGNED_LONG EQUAL SIZEOF_SIZE_T)
  set(TIFF_SIZE_T "unsigned long")
  set(TIFF_SIZE_FORMAT "%lu")
-  set(TIFF_SSIZE_T "signed long")
-  set(TIFF_SSIZE_FORMAT "%ld")
 elseif(SIZEOF_UNSIGNED_LONG_LONG EQUAL SIZEOF_SIZE_T)
  set(TIFF_SIZE_T "unsigned long")
  if(MINGW)
    set(TIFF_SIZE_FORMAT "%I64u")
-    set(TIFF_SSIZE_FORMAT "%I64d")
  else()
    set(TIFF_SIZE_FORMAT "%llu")
-    set(TIFF_SSIZE_FORMAT "%lld")
  endif()
 endif()

 if(SIZEOF_SIGNED_INT EQUAL SIZEOF_UNSIGNED_CHAR_P)
+  set(TIFF_SSIZE_T "signed int")
+  set(TIFF_SSIZE_FORMAT "%d")
 elseif(SIZEOF_SIGNED_LONG EQUAL SIZEOF_UNSIGNED_CHAR_P)
+  set(TIFF_SSIZE_T "signed long")
+  set(TIFF_SSIZE_FORMAT "%ld")
 elseif(SIZEOF_SIGNED_LONG_LONG EQUAL SIZEOF_UNSIGNED_CHAR_P)
  set(TIFF_SSIZE_T "signed long long")
  if(MINGW)
+    set(TIFF_SSIZE_FORMAT "%I64d")
  else()
+    set(TIFF_SSIZE_FORMAT "%lld")
  endif()
 endif()

@@ -216,8 +216,6 @@ endif()
 set(fillorder FILLORDER_MSB2LSB)
 if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "i.*86.*" OR
   CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "amd64.*" OR
-   # AMD64 on Windows
-   CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "AMD64" OR
   CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "x86_64.*")
  set(fillorder FILLORDER_LSB2MSB)
 endif()
@@ -16,11 +16,7 @@ int _TIFF_vsnprintf_f(char* str, size_t size, const char* format, va_list ap)
  int count = -1;

  if (size != 0)
-#if _MSC_VER <=	1310
-    count = _vsnprintf(str, size, format, ap);
-#else
    count = _vsnprintf_s(str, size, _TRUNCATE, format, ap);
-#endif
  if (count == -1)
    count = _vscprintf(format, ap);

@@ -30,7 +30,6 @@
 #include "tiffiop.h"
 #include "tif_predict.h"
 #include <math.h>
-#include <float.h>

 uint32
 _TIFFMultiply32(TIFF* tif, uint32 first, uint32 second, const char* where)
@@ -358,15 +357,6 @@ _TIFFUInt64ToDouble(uint64 ui64)
 	}
 }

-float _TIFFClampDoubleToFloat( double val )
-{
-    if( val > FLT_MAX )
-        return FLT_MAX;
-    if( val < -FLT_MAX )
-        return -FLT_MAX;
-    return (float)val;
-}
-
 int _TIFFSeekOK(TIFF* tif, toff_t off)
 {
    /* Huge offsets, especially -1 / UINT64_MAX, can cause issues */
@@ -216,7 +216,7 @@
 #endif

 /* Number of bits in a file offset, on hosts where this is settable. */
-#define _FILE_OFFSET_BITS @FILE_OFFSET_BITS@
+//disabled for OpenCV CMakeLists.txt: #define _FILE_OFFSET_BITS @FILE_OFFSET_BITS@

 /* Define to `__inline__' or `__inline' if that's what the C compiler
   calls it, or to nothing if 'inline' is not supported under any name.  */
@@ -29,6 +29,7 @@
 * (and also some miscellaneous stuff)
 */
 #include "tiffiop.h"
+#include <float.h>

 /*
 * These are used in the backwards compatibility code...
@@ -87,15 +88,13 @@ setDoubleArrayOneValue(double** vpp, double value, size_t nmemb)
 * Install extra samples information.
 */
 static int
-setExtraSamples(TIFF* tif, va_list ap, uint32* v)
+setExtraSamples(TIFFDirectory* td, va_list ap, uint32* v)
 {
 /* XXX: Unassociated alpha data == 999 is a known Corel Draw bug, see below */
 #define EXTRASAMPLE_COREL_UNASSALPHA 999 

 	uint16* va;
 	uint32 i;
-        TIFFDirectory* td = &tif->tif_dir;
-        static const char module[] = "setExtraSamples";

 	*v = (uint16) va_arg(ap, uint16_vap);
 	if ((uint16) *v > td->td_samplesperpixel)
@@ -117,18 +116,6 @@ setExtraSamples(TIFF* tif, va_list ap, uint32* v)
 				return 0;
 		}
 	}
-
-        if ( td->td_transferfunction[0] != NULL && (td->td_samplesperpixel - *v > 1) &&
-                !(td->td_samplesperpixel - td->td_extrasamples > 1))
-        {
-                TIFFWarningExt(tif->tif_clientdata,module,
-                    "ExtraSamples tag value is changing, "
-                    "but TransferFunction was read with a different value. Cancelling it");
-                TIFFClrFieldBit(tif,FIELD_TRANSFERFUNCTION);
-                _TIFFfree(td->td_transferfunction[0]);
-                td->td_transferfunction[0] = NULL;
-        }
-
 	td->td_extrasamples = (uint16) *v;
 	_TIFFsetShortArray(&td->td_sampleinfo, va, td->td_extrasamples);
 	return 1;
@@ -166,6 +153,15 @@ bad:
 	return (0);
 }

+static float TIFFClampDoubleToFloat( double val )
+{
+    if( val > FLT_MAX )
+        return FLT_MAX;
+    if( val < -FLT_MAX )
+        return -FLT_MAX;
+    return (float)val;
+}
+
 static int
 _TIFFVSetField(TIFF* tif, uint32 tag, va_list ap)
 {
@@ -289,18 +285,6 @@ _TIFFVSetField(TIFF* tif, uint32 tag, va_list ap)
                _TIFFfree(td->td_smaxsamplevalue);
                td->td_smaxsamplevalue = NULL;
            }
-            /* Test if 3 transfer functions instead of just one are now needed
-               See http://bugzilla.maptools.org/show_bug.cgi?id=2820 */
-            if( td->td_transferfunction[0] != NULL && (v - td->td_extrasamples > 1) &&
-                !(td->td_samplesperpixel - td->td_extrasamples > 1))
-            {
-                    TIFFWarningExt(tif->tif_clientdata,module,
-                        "SamplesPerPixel tag value is changing, "
-                        "but TransferFunction was read with a different value. Cancelling it");
-                    TIFFClrFieldBit(tif,FIELD_TRANSFERFUNCTION);
-                    _TIFFfree(td->td_transferfunction[0]);
-                    td->td_transferfunction[0] = NULL;
-            }
        }
 		td->td_samplesperpixel = (uint16) v;
 		break;
@@ -336,13 +320,13 @@ _TIFFVSetField(TIFF* tif, uint32 tag, va_list ap)
        dblval = va_arg(ap, double);
        if( dblval < 0 )
            goto badvaluedouble;
-		td->td_xresolution = _TIFFClampDoubleToFloat( dblval );
+		td->td_xresolution = TIFFClampDoubleToFloat( dblval );
 		break;
 	case TIFFTAG_YRESOLUTION:
        dblval = va_arg(ap, double);
        if( dblval < 0 )
            goto badvaluedouble;
-		td->td_yresolution = _TIFFClampDoubleToFloat( dblval );
+		td->td_yresolution = TIFFClampDoubleToFloat( dblval );
 		break;
 	case TIFFTAG_PLANARCONFIG:
 		v = (uint16) va_arg(ap, uint16_vap);
@@ -351,10 +335,10 @@ _TIFFVSetField(TIFF* tif, uint32 tag, va_list ap)
 		td->td_planarconfig = (uint16) v;
 		break;
 	case TIFFTAG_XPOSITION:
-		td->td_xposition = _TIFFClampDoubleToFloat( va_arg(ap, double) );
+		td->td_xposition = TIFFClampDoubleToFloat( va_arg(ap, double) );
 		break;
 	case TIFFTAG_YPOSITION:
-		td->td_yposition = _TIFFClampDoubleToFloat( va_arg(ap, double) );
+		td->td_yposition = TIFFClampDoubleToFloat( va_arg(ap, double) );
 		break;
 	case TIFFTAG_RESOLUTIONUNIT:
 		v = (uint16) va_arg(ap, uint16_vap);
@@ -377,7 +361,7 @@ _TIFFVSetField(TIFF* tif, uint32 tag, va_list ap)
 		_TIFFsetShortArray(&td->td_colormap[2], va_arg(ap, uint16*), v32);
 		break;
 	case TIFFTAG_EXTRASAMPLES:
-		if (!setExtraSamples(tif, ap, &v))
+		if (!setExtraSamples(td, ap, &v))
 			goto badvalue;
 		break;
 	case TIFFTAG_MATTEING:
@@ -700,7 +684,7 @@ _TIFFVSetField(TIFF* tif, uint32 tag, va_list ap)
 				case TIFF_SRATIONAL:
 				case TIFF_FLOAT:
 					{
-						float v2 = _TIFFClampDoubleToFloat(va_arg(ap, double));
+						float v2 = TIFFClampDoubleToFloat(va_arg(ap, double));
 						_TIFFmemcpy(val, &v2, tv_size);
 					}
 					break;
@@ -164,7 +164,6 @@ static int TIFFFetchNormalTag(TIFF*, TIFFDirEntry*, int recover);
 static int TIFFFetchStripThing(TIFF* tif, TIFFDirEntry* dir, uint32 nstrips, uint64** lpp);
 static int TIFFFetchSubjectDistance(TIFF*, TIFFDirEntry*);
 static void ChopUpSingleUncompressedStrip(TIFF*);
-static void TryChopUpUncompressedBigTiff(TIFF*);
 static uint64 TIFFReadUInt64(const uint8 *value);
 static int _TIFFGetMaxColorChannels(uint16 photometric);

@@ -4247,19 +4246,6 @@ TIFFReadDirectory(TIFF* tif)
 		ChopUpSingleUncompressedStrip(tif);
    }

-        /* There are also uncompressed stripped files with strips larger than */
-        /* 2 GB, which make them unfriendly with a lot of code. If possible, */
-        /* try to expose smaller "virtual" strips. */
-        if( tif->tif_dir.td_planarconfig == PLANARCONFIG_CONTIG &&
-            tif->tif_dir.td_compression == COMPRESSION_NONE &&
-            (tif->tif_flags&(TIFF_STRIPCHOP|TIFF_ISTILED)) == TIFF_STRIPCHOP &&
-            TIFFStripSize64(tif) > 0x7FFFFFFFUL )
-        {
-            if ( !_TIFFFillStriles(tif) || !tif->tif_dir.td_stripbytecount )
-                return 0;
-            TryChopUpUncompressedBigTiff(tif);
-        }
-
        /*
         * Clear the dirty directory flag. 
         */
@@ -5713,63 +5699,6 @@ TIFFFetchSubjectDistance(TIFF* tif, TIFFDirEntry* dir)
 	}
 }

-static void allocChoppedUpStripArrays(TIFF* tif, uint32 nstrips,
-                                      uint64 stripbytes, uint32 rowsperstrip)
-{
-    TIFFDirectory *td = &tif->tif_dir;
-    uint64 bytecount;
-    uint64 offset;
-    uint32 i;
-    uint64 *newcounts;
-    uint64 *newoffsets;
-
-    newcounts = (uint64*) _TIFFCheckMalloc(tif, nstrips, sizeof (uint64),
-                            "for chopped \"StripByteCounts\" array");
-    newoffsets = (uint64*) _TIFFCheckMalloc(tif, nstrips, sizeof (uint64),
-                            "for chopped \"StripOffsets\" array");
-    if (newcounts == NULL || newoffsets == NULL) {
-        /*
-        * Unable to allocate new strip information, give up and use
-        * the original one strip information.
-        */
-        if (newcounts != NULL)
-            _TIFFfree(newcounts);
-        if (newoffsets != NULL)
-            _TIFFfree(newoffsets);
-        return;
-    }
-
-    /*
-     * Fill the strip information arrays with new bytecounts and offsets
-     * that reflect the broken-up format.
-     */
-    offset = td->td_stripoffset[0];
-    bytecount = td->td_stripoffset[td->td_nstrips-1] +
-                td->td_stripbytecount[td->td_nstrips-1] - offset;
-    for (i = 0; i < nstrips; i++)
-    {
-        if (stripbytes > bytecount)
-            stripbytes = bytecount;
-        newcounts[i] = stripbytes;
-        newoffsets[i] = stripbytes ? offset : 0;
-        offset += stripbytes;
-        bytecount -= stripbytes;
-    }
-
-    /*
-     * Replace old single strip info with multi-strip info.
-     */
-    td->td_stripsperimage = td->td_nstrips = nstrips;
-    TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, rowsperstrip);
-
-    _TIFFfree(td->td_stripbytecount);
-    _TIFFfree(td->td_stripoffset);
-    td->td_stripbytecount = newcounts;
-    td->td_stripoffset = newoffsets;
-    td->td_stripbytecountsorted = 1;
-}
-
-
 /*
 * Replace a single strip (tile) of uncompressed data by multiple strips
 * (tiles), each approximately STRIP_SIZE_DEFAULT bytes. This is useful for
@@ -5785,8 +5714,11 @@ ChopUpSingleUncompressedStrip(TIFF* tif)
 	uint32 rowblock;
 	uint64 rowblockbytes;
 	uint64 stripbytes;
+	uint32 strip;
 	uint32 nstrips;
 	uint32 rowsperstrip;
+	uint64* newcounts;
+	uint64* newoffsets;

 	bytecount = td->td_stripbytecount[0];
        /* On a newly created file, just re-opened to be filled, we */
@@ -5837,106 +5769,46 @@ ChopUpSingleUncompressedStrip(TIFF* tif)
            return;
        }

-        allocChoppedUpStripArrays(tif, nstrips, stripbytes, rowsperstrip);
+	newcounts = (uint64*) _TIFFCheckMalloc(tif, nstrips, sizeof (uint64),
+				"for chopped \"StripByteCounts\" array");
+	newoffsets = (uint64*) _TIFFCheckMalloc(tif, nstrips, sizeof (uint64),
+				"for chopped \"StripOffsets\" array");
+	if (newcounts == NULL || newoffsets == NULL) {
+		/*
+		 * Unable to allocate new strip information, give up and use
+		 * the original one strip information.
+		 */
+		if (newcounts != NULL)
+			_TIFFfree(newcounts);
+		if (newoffsets != NULL)
+			_TIFFfree(newoffsets);
+		return;
+	}
+	/*
+	 * Fill the strip information arrays with new bytecounts and offsets
+	 * that reflect the broken-up format.
+	 */
+	for (strip = 0; strip < nstrips; strip++) {
+		if (stripbytes > bytecount)
+			stripbytes = bytecount;
+		newcounts[strip] = stripbytes;
+		newoffsets[strip] = stripbytes ? offset : 0;
+		offset += stripbytes;
+		bytecount -= stripbytes;
+	}
+	/*
+	 * Replace old single strip info with multi-strip info.
+	 */
+	td->td_stripsperimage = td->td_nstrips = nstrips;
+	TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, rowsperstrip);
+
+	_TIFFfree(td->td_stripbytecount);
+	_TIFFfree(td->td_stripoffset);
+	td->td_stripbytecount = newcounts;
+	td->td_stripoffset = newoffsets;
+	td->td_stripbytecountsorted = 1;
 }

-
-/*
- * Replace a file with contiguous strips > 2 GB of uncompressed data by
- * multiple smaller strips. This is useful for
- * dealing with large images or for dealing with machines with a limited
- * amount memory.
- */
-static void TryChopUpUncompressedBigTiff( TIFF* tif )
-{
-    TIFFDirectory *td = &tif->tif_dir;
-    uint32 rowblock;
-    uint64 rowblockbytes;
-    uint32 i;
-    uint64 stripsize;
-    uint32 rowblocksperstrip;
-    uint32 rowsperstrip;
-    uint64 stripbytes;
-    uint32 nstrips;
-
-    stripsize = TIFFStripSize64(tif);
-
-    assert( tif->tif_dir.td_planarconfig == PLANARCONFIG_CONTIG );
-    assert( tif->tif_dir.td_compression == COMPRESSION_NONE );
-    assert( (tif->tif_flags&(TIFF_STRIPCHOP|TIFF_ISTILED)) == TIFF_STRIPCHOP );
-    assert( stripsize > 0x7FFFFFFFUL );
-
-    /* On a newly created file, just re-opened to be filled, we */
-    /* don't want strip chop to trigger as it is going to cause issues */
-    /* later ( StripOffsets and StripByteCounts improperly filled) . */
-    if( td->td_stripbytecount[0] == 0 && tif->tif_mode != O_RDONLY )
-        return;
-
-    if ((td->td_photometric == PHOTOMETRIC_YCBCR)&&
-        (!isUpSampled(tif)))
-        rowblock = td->td_ycbcrsubsampling[1];
-    else
-        rowblock = 1;
-    rowblockbytes = TIFFVStripSize64(tif, rowblock);
-    if( rowblockbytes == 0 || rowblockbytes > 0x7FFFFFFFUL )
-    {
-        /* In case of file with gigantic width */
-        return;
-    }
-
-    /* Check that the strips are contiguous and of the expected size */
-    for( i = 0; i < td->td_nstrips; i++ )
-    {
-        if( i == td->td_nstrips - 1 )
-        {
-            if( td->td_stripbytecount[i] < TIFFVStripSize64(
-                    tif, td->td_imagelength - i * td->td_rowsperstrip ) )
-            {
-                return;
-            }
-        }
-        else
-        {
-            if( td->td_stripbytecount[i] != stripsize )
-            {
-                return;
-            }
-            if( i > 0 && td->td_stripoffset[i] !=
-                    td->td_stripoffset[i-1] + td->td_stripbytecount[i - 1] )
-            {
-                return;
-            }
-        }
-    }
-
-    /* Aim for 512 MB strips (that will still be manageable by 32 bit builds */
-    rowblocksperstrip = (uint32) (512 * 1024 * 1024 / rowblockbytes);
-    if( rowblocksperstrip == 0 )
-        rowblocksperstrip = 1;
-    rowsperstrip = rowblocksperstrip * rowblock;
-    stripbytes = rowblocksperstrip * rowblockbytes;
-    assert( stripbytes <= 0x7FFFFFFFUL );
-
-    nstrips = TIFFhowmany_32(td->td_imagelength, rowsperstrip);
-    if( nstrips == 0 )
-        return;
-
-    /* If we are going to allocate a lot of memory, make sure that the */
-    /* file is as big as needed */
-    if( tif->tif_mode == O_RDONLY &&
-        nstrips > 1000000 &&
-        (td->td_stripoffset[td->td_nstrips-1] > TIFFGetFileSize(tif) ||
-         td->td_stripoffset[td->td_nstrips-1] +
-         td->td_stripbytecount[td->td_nstrips-1] > TIFFGetFileSize(tif)) )
-    {
-        return;
-    }
-
-    allocChoppedUpStripArrays(tif, nstrips, stripbytes, rowsperstrip);
-}
-
-
-
 int _TIFFFillStriles( TIFF *tif )
 {
    return _TIFFFillStrilesInternal( tif, 1 );
@@ -28,6 +28,7 @@
 * Directory Write Support Routines.
 */
 #include "tiffiop.h"
+#include <float.h>

 #ifdef HAVE_IEEEFP
 #define TIFFCvtNativeToIEEEFloat(tif, n, fp)
@@ -945,6 +946,15 @@ bad:
 	return(0);
 }

+static float TIFFClampDoubleToFloat( double val )
+{
+    if( val > FLT_MAX )
+        return FLT_MAX;
+    if( val < -FLT_MAX )
+        return -FLT_MAX;
+    return (float)val;
+}
+
 static int8 TIFFClampDoubleToInt8( double val )
 {
    if( val > 127 )
@@ -1019,7 +1029,7 @@ TIFFWriteDirectoryTagSampleformatArray(TIFF* tif, uint32* ndir, TIFFDirEntry* di
 			if (tif->tif_dir.td_bitspersample<=32)
 			{
 				for (i = 0; i < count; ++i)
-					((float*)conv)[i] = _TIFFClampDoubleToFloat(value[i]);
+					((float*)conv)[i] = TIFFClampDoubleToFloat(value[i]);
 				ok = TIFFWriteDirectoryTagFloatArray(tif,ndir,dir,tag,count,(float*)conv);
 			}
 			else
@@ -1883,14 +1893,12 @@ TIFFWriteDirectoryTagTransferfunction(TIFF* tif, uint32* ndir, TIFFDirEntry* dir
 		n=3;
 	if (n==3)
 	{
-		if (tif->tif_dir.td_transferfunction[2] == NULL ||
-		    !_TIFFmemcmp(tif->tif_dir.td_transferfunction[0],tif->tif_dir.td_transferfunction[2],m*sizeof(uint16)))
+		if (!_TIFFmemcmp(tif->tif_dir.td_transferfunction[0],tif->tif_dir.td_transferfunction[2],m*sizeof(uint16)))
 			n=2;
 	}
 	if (n==2)
 	{
-		if (tif->tif_dir.td_transferfunction[1] == NULL ||
-		    !_TIFFmemcmp(tif->tif_dir.td_transferfunction[0],tif->tif_dir.td_transferfunction[1],m*sizeof(uint16)))
+		if (!_TIFFmemcmp(tif->tif_dir.td_transferfunction[0],tif->tif_dir.td_transferfunction[1],m*sizeof(uint16)))
 			n=1;
 	}
 	if (n==0)
@@ -742,14 +742,9 @@ LogLuvEncodeTile(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
 #undef exp2  /* Conflict with C'99 function */
 #define exp2(x)		exp(M_LN2*(x))

-static int itrunc(double x, int m)
-{
-    if( m == SGILOGENCODE_NODITHER )
-        return (int)x;
-    /* Silence CoverityScan warning about bad crypto function */
-    /* coverity[dont_call] */
-    return (int)(x + rand()*(1./RAND_MAX) - .5);
-}
+#define itrunc(x,m)	((m)==SGILOGENCODE_NODITHER ? \
+				(int)(x) : \
+				(int)((x) + rand()*(1./RAND_MAX) - .5))

 #if !LOGLUV_PUBLIC
 static
@@ -247,8 +247,6 @@ LZWSetupDecode(TIFF* tif)
 		/*
 		 * Zero-out the unused entries
                 */
-                /* Silence false positive */
-                /* coverity[overrun-buffer-arg] */
                 _TIFFmemset(&sp->dec_codetab[CODE_CLEAR], 0,
 			     (CODE_FIRST - CODE_CLEAR) * sizeof (code_t));
 	}
@@ -640,7 +640,6 @@ PixarLogGuessDataFmt(TIFFDirectory *td)
 static tmsize_t
 multiply_ms(tmsize_t m1, tmsize_t m2)
 {
-        assert(m1 >= 0 && m2 >= 0);
        if( m1 == 0 || m2 > TIFF_TMSIZE_T_MAX / m1 )
            return 0;
        return m1 * m2;
@@ -649,7 +648,6 @@ multiply_ms(tmsize_t m1, tmsize_t m2)
 static tmsize_t
 add_ms(tmsize_t m1, tmsize_t m2)
 {
-        assert(m1 >= 0 && m2 >= 0);
 	/* if either input is zero, assume overflow already occurred */
 	if (m1 == 0 || m2 == 0)
 		return 0;
@@ -819,7 +817,9 @@ PixarLogDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
 			TIFFErrorExt(tif->tif_clientdata, module,
 			    "Decoding error at scanline %lu, %s",
 			    (unsigned long) tif->tif_row, sp->stream.msg ? sp->stream.msg : "(null)");
-			return (0);
+			if (inflateSync(&sp->stream) != Z_OK)
+				return (0);
+			continue;
 		}
 		if (state != Z_OK) {
 			TIFFErrorExt(tif->tif_clientdata, module, "ZLib error: %s",
@@ -103,11 +103,6 @@ static int TIFFReadAndRealloc( TIFF* tif, tmsize_t size,
                }
                tif->tif_rawdata = new_rawdata;
            }
-            if( tif->tif_rawdata == NULL )
-            {
-                /* should not happen in practice but helps CoverityScan */
-                return 0;
-            }

            bytes_read = TIFFReadFile(tif,
                tif->tif_rawdata + rawdata_offset + already_read, to_read);
@@ -1372,8 +1367,7 @@ TIFFFillTile(TIFF* tif, uint32 tile)
                        tif->tif_rawdataoff = 0;
                        tif->tif_rawdataloaded = bytecountm;
                        
-			if (tif->tif_rawdata != NULL &&
-                            !isFillOrder(tif, td->td_fillorder) &&
+			if (!isFillOrder(tif, td->td_fillorder) &&
 			    (tif->tif_flags & TIFF_NOBITREV) == 0)
 				TIFFReverseBits(tif->tif_rawdata,
                                                tif->tif_rawdataloaded);
@@ -349,12 +349,6 @@ TWebPSetupEncode(TIFF* tif)

  sp->state |= LSTATE_INIT_ENCODE;

-  if (!WebPPictureInit(&sp->sPicture)) {
-    TIFFErrorExt(tif->tif_clientdata, module,
-        "Error initializing WebP picture.");
-    return 0;
-  }
-
  if (!WebPConfigInitInternal(&sp->sEncoderConfig, WEBP_PRESET_DEFAULT,
                              sp->quality_level,
                              WEBP_ENCODER_ABI_VERSION)) {
@@ -363,13 +357,9 @@ TWebPSetupEncode(TIFF* tif)
    return 0;
  }

-  // WebPConfigInitInternal above sets lossless to false
-  #if WEBP_ENCODER_ABI_VERSION >= 0x0100
-    sp->sEncoderConfig.lossless = sp->lossless;
-    if (sp->lossless) {
-      sp->sPicture.use_argb = 1;
-    }
-  #endif
+#if WEBP_ENCODER_ABI_VERSION >= 0x0100
+  sp->sEncoderConfig.lossless = sp->lossless;
+#endif

  if (!WebPValidateConfig(&sp->sEncoderConfig)) {
    TIFFErrorExt(tif->tif_clientdata, module,
@@ -377,6 +367,12 @@ TWebPSetupEncode(TIFF* tif)
    return 0;
  }

+  if (!WebPPictureInit(&sp->sPicture)) {
+    TIFFErrorExt(tif->tif_clientdata, module,
+        "Error initializing WebP picture.");
+    return 0;
+  }
+
  return 1;
 }

@@ -419,12 +415,6 @@ TWebPPreEncode(TIFF* tif, uint16 s)
  /* set up buffer for raw data */
  /* given above check and that nSamples <= 4, buffer_size is <= 1 GB */
  sp->buffer_size = segment_width * segment_height * sp->nSamples;
-  
-  if (sp->pBuffer != NULL) {
-      _TIFFfree(sp->pBuffer);
-      sp->pBuffer = NULL;    
-  }
-  
  sp->pBuffer = _TIFFmalloc(sp->buffer_size);
  if( !sp->pBuffer) {
      TIFFErrorExt(tif->tif_clientdata, module, "Cannot allocate buffer");
@@ -470,7 +460,7 @@ TWebPPostEncode(TIFF* tif)
                    "WebPPictureImportRGB() failed");
      return 0;
  }
-  
+
  if (!WebPEncode(&sp->sEncoderConfig, &sp->sPicture)) {

 #if WEBP_ENCODER_ABI_VERSION >= 0x0100
@@ -550,13 +540,15 @@ TWebPCleanup(TIFF* tif)
  }
  
  if (sp->pBuffer != NULL) {
-      _TIFFfree(sp->pBuffer);
-      sp->pBuffer = NULL;    
+    _TIFFfree(sp->pBuffer);
+    sp->pBuffer = NULL;
  }

-  _TIFFfree(tif->tif_data);
-  tif->tif_data = NULL;
-
+  if (tif->tif_data) {
+    _TIFFfree(tif->tif_data);
+    tif->tif_data = NULL;
+  }
+  
  _TIFFSetDefaultCompressionState(tif);
 }

@@ -578,9 +570,6 @@ TWebPVSetField(TIFF* tif, uint32 tag, va_list ap)
  case TIFFTAG_WEBP_LOSSLESS:
    #if WEBP_ENCODER_ABI_VERSION >= 0x0100
    sp->lossless = va_arg(ap, int);
-    if (sp->lossless){
-      sp->quality_level = 100.0f;      
-    }
    return 1;
    #else
      TIFFErrorExt(tif->tif_clientdata, module,
@@ -124,6 +124,7 @@ ZIPSetupDecode(TIFF* tif)
 static int
 ZIPPreDecode(TIFF* tif, uint16 s)
 {
+	static const char module[] = "ZIPPreDecode";
 	ZIPState* sp = DecoderState(tif);

 	(void) s;
@@ -137,7 +138,12 @@ ZIPPreDecode(TIFF* tif, uint16 s)
 	    we need to simplify this code to reflect a ZLib that is likely updated
 	    to deal with 8byte memory sizes, though this code will respond
 	    appropriately even before we simplify it */
-	sp->stream.avail_in = (uint64)tif->tif_rawcc < 0xFFFFFFFFU ? (uInt) tif->tif_rawcc : 0xFFFFFFFFU;
+	sp->stream.avail_in = (uInt) tif->tif_rawcc;
+	if ((tmsize_t)sp->stream.avail_in != tif->tif_rawcc)
+	{
+		TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size");
+		return (0);
+	}
 	return (inflateReset(&sp->stream) == Z_OK);
 }

@@ -152,43 +158,46 @@ ZIPDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
 	assert(sp->state == ZSTATE_INIT_DECODE);

        sp->stream.next_in = tif->tif_rawcp;
+	sp->stream.avail_in = (uInt) tif->tif_rawcc;
        
 	sp->stream.next_out = op;
 	assert(sizeof(sp->stream.avail_out)==4);  /* if this assert gets raised,
 	    we need to simplify this code to reflect a ZLib that is likely updated
 	    to deal with 8byte memory sizes, though this code will respond
 	    appropriately even before we simplify it */
+	sp->stream.avail_out = (uInt) occ;
+	if ((tmsize_t)sp->stream.avail_out != occ)
+	{
+		TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size");
+		return (0);
+	}
 	do {
-                int state;
-                uInt avail_in_before = (uint64)tif->tif_rawcc <= 0xFFFFFFFFU ? (uInt)tif->tif_rawcc : 0xFFFFFFFFU;
-                uInt avail_out_before = (uint64)occ < 0xFFFFFFFFU ? (uInt) occ : 0xFFFFFFFFU;
-                sp->stream.avail_in = avail_in_before;
-                sp->stream.avail_out = avail_out_before;
-		state = inflate(&sp->stream, Z_PARTIAL_FLUSH);
-		tif->tif_rawcc -= (avail_in_before - sp->stream.avail_in);
-                occ -= (avail_out_before - sp->stream.avail_out);
+		int state = inflate(&sp->stream, Z_PARTIAL_FLUSH);
 		if (state == Z_STREAM_END)
 			break;
 		if (state == Z_DATA_ERROR) {
 			TIFFErrorExt(tif->tif_clientdata, module,
 			    "Decoding error at scanline %lu, %s",
 			     (unsigned long) tif->tif_row, SAFE_MSG(sp));
-			return (0);
+			if (inflateSync(&sp->stream) != Z_OK)
+				return (0);
+			continue;
 		}
 		if (state != Z_OK) {
 			TIFFErrorExt(tif->tif_clientdata, module, 
 				     "ZLib error: %s", SAFE_MSG(sp));
 			return (0);
 		}
-	} while (occ > 0);
-	if (occ != 0) {
+	} while (sp->stream.avail_out > 0);
+	if (sp->stream.avail_out != 0) {
 		TIFFErrorExt(tif->tif_clientdata, module,
 		    "Not enough data at scanline %lu (short " TIFF_UINT64_FORMAT " bytes)",
-		    (unsigned long) tif->tif_row, (TIFF_UINT64_T) occ);
+		    (unsigned long) tif->tif_row, (TIFF_UINT64_T) sp->stream.avail_out);
 		return (0);
 	}

        tif->tif_rawcp = sp->stream.next_in;
+        tif->tif_rawcc = sp->stream.avail_in;

 	return (1);
 }
@@ -220,6 +229,7 @@ ZIPSetupEncode(TIFF* tif)
 static int
 ZIPPreEncode(TIFF* tif, uint16 s)
 {
+	static const char module[] = "ZIPPreEncode";
 	ZIPState *sp = EncoderState(tif);

 	(void) s;
@@ -232,7 +242,12 @@ ZIPPreEncode(TIFF* tif, uint16 s)
 	    we need to simplify this code to reflect a ZLib that is likely updated
 	    to deal with 8byte memory sizes, though this code will respond
 	    appropriately even before we simplify it */
-	sp->stream.avail_out = (uint64)tif->tif_rawdatasize <= 0xFFFFFFFFU ? (uInt)tif->tif_rawdatasize : 0xFFFFFFFFU;
+	sp->stream.avail_out = (uInt)tif->tif_rawdatasize;
+	if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize)
+	{
+		TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size");
+		return (0);
+	}
 	return (deflateReset(&sp->stream) == Z_OK);
 }

@@ -254,9 +269,13 @@ ZIPEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
 	    we need to simplify this code to reflect a ZLib that is likely updated
 	    to deal with 8byte memory sizes, though this code will respond
 	    appropriately even before we simplify it */
+	sp->stream.avail_in = (uInt) cc;
+	if ((tmsize_t)sp->stream.avail_in != cc)
+	{
+		TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size");
+		return (0);
+	}
 	do {
-                uInt avail_in_before = (uint64)cc <= 0xFFFFFFFFU ? (uInt)cc : 0xFFFFFFFFU;
-                sp->stream.avail_in = avail_in_before;
 		if (deflate(&sp->stream, Z_NO_FLUSH) != Z_OK) {
 			TIFFErrorExt(tif->tif_clientdata, module, 
 				     "Encoder error: %s",
@@ -267,10 +286,9 @@ ZIPEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
 			tif->tif_rawcc = tif->tif_rawdatasize;
 			TIFFFlushData1(tif);
 			sp->stream.next_out = tif->tif_rawdata;
-			sp->stream.avail_out = (uint64)tif->tif_rawdatasize <= 0xFFFFFFFFU ? (uInt)tif->tif_rawdatasize : 0xFFFFFFFFU;
+			sp->stream.avail_out = (uInt) tif->tif_rawdatasize;  /* this is a safe typecast, as check is made already in ZIPPreEncode */
 		}
-		cc -= (avail_in_before - sp->stream.avail_in);
-	} while (cc > 0);
+	} while (sp->stream.avail_in > 0);
 	return (1);
 }

@@ -296,7 +314,7 @@ ZIPPostEncode(TIFF* tif)
 				tif->tif_rawcc =  tif->tif_rawdatasize - sp->stream.avail_out;
 				TIFFFlushData1(tif);
 				sp->stream.next_out = tif->tif_rawdata;
-				sp->stream.avail_out = (uint64)tif->tif_rawdatasize <= 0xFFFFFFFFU ? (uInt)tif->tif_rawdatasize : 0xFFFFFFFFU;
+				sp->stream.avail_out = (uInt) tif->tif_rawdatasize;  /* this is a safe typecast, as check is made already in ZIPPreEncode */
 			}
 			break;
 		default:
@@ -374,8 +374,6 @@ extern void* _TIFFCheckRealloc(TIFF*, void*, tmsize_t, tmsize_t, const char*);
 extern double _TIFFUInt64ToDouble(uint64);
 extern float _TIFFUInt64ToFloat(uint64);

-extern float _TIFFClampDoubleToFloat(double);
-
 extern tmsize_t
 _TIFFReadEncodedStripAndAllocBuffer(TIFF* tif, uint32 strip,
                                    void **buf, tmsize_t bufsizetoalloc,
@@ -732,7 +732,7 @@ static int AllocateMemory(VP8Decoder* const dec) {
  mem += f_info_size;
  dec->thread_ctx_.id_ = 0;
  dec->thread_ctx_.f_info_ = dec->f_info_;
-  if (dec->filter_type_ > 0 && dec->mt_method_ > 0) {
+  if (dec->mt_method_ > 0) {
    // secondary cache line. The deblocking process need to make use of the
    // filtering strength from previous macroblock row, while the new ones
    // are being decoded in parallel. We'll just swap the pointers.
@@ -166,11 +166,9 @@ static int AppendToMemBuffer(WebPIDecoder* const idec,
  VP8Decoder* const dec = (VP8Decoder*)idec->dec_;
  MemBuffer* const mem = &idec->mem_;
  const int need_compressed_alpha = NeedCompressedAlpha(idec);
-  const uint8_t* const old_start =
-      (mem->buf_ == NULL) ? NULL : mem->buf_ + mem->start_;
+  const uint8_t* const old_start = mem->buf_ + mem->start_;
  const uint8_t* const old_base =
      need_compressed_alpha ? dec->alpha_data_ : old_start;
-  assert(mem->buf_ != NULL || mem->start_ == 0);
  assert(mem->mode_ == MEM_MODE_APPEND);
  if (data_size > MAX_CHUNK_PAYLOAD) {
    // security safeguard: trying to allocate more than what the format
@@ -186,7 +184,7 @@ static int AppendToMemBuffer(WebPIDecoder* const idec,
    uint8_t* const new_buf =
        (uint8_t*)WebPSafeMalloc(extra_size, sizeof(*new_buf));
    if (new_buf == NULL) return 0;
-    if (old_base != NULL) memcpy(new_buf, old_base, current_size);
+    memcpy(new_buf, old_base, current_size);
    WebPSafeFree(mem->buf_);
    mem->buf_ = new_buf;
    mem->buf_size_ = (size_t)extra_size;
@@ -194,7 +192,6 @@ static int AppendToMemBuffer(WebPIDecoder* const idec,
    mem->end_ = current_size;
  }

-  assert(mem->buf_ != NULL);
  memcpy(mem->buf_ + mem->end_, data, data_size);
  mem->end_ += data_size;
  assert(mem->end_ <= mem->buf_size_);
@@ -207,9 +204,7 @@ static int RemapMemBuffer(WebPIDecoder* const idec,
                          const uint8_t* const data, size_t data_size) {
  MemBuffer* const mem = &idec->mem_;
  const uint8_t* const old_buf = mem->buf_;
-  const uint8_t* const old_start =
-      (old_buf == NULL) ? NULL : old_buf + mem->start_;
-  assert(old_buf != NULL || mem->start_ == 0);
+  const uint8_t* const old_start = old_buf + mem->start_;
  assert(mem->mode_ == MEM_MODE_MAP);

  if (data_size < mem->buf_size_) return 0;  // can't remap to a shorter buffer!
@@ -31,8 +31,8 @@ extern "C" {

 // version numbers
 #define DEC_MAJ_VERSION 1
-#define DEC_MIN_VERSION 1
-#define DEC_REV_VERSION 0
+#define DEC_MIN_VERSION 0
+#define DEC_REV_VERSION 3

 // YUV-cache parameters. Cache is 32-bytes wide (= one cacheline).
 // Constraints are: We need to store one 16x16 block of luma samples (y),
@@ -754,11 +754,11 @@ static WEBP_INLINE HTreeGroup* GetHtreeGroupForPos(VP8LMetadata* const hdr,

 typedef void (*ProcessRowsFunc)(VP8LDecoder* const dec, int row);

-static void ApplyInverseTransforms(VP8LDecoder* const dec,
-                                   int start_row, int num_rows,
+static void ApplyInverseTransforms(VP8LDecoder* const dec, int num_rows,
                                   const uint32_t* const rows) {
  int n = dec->next_transform_;
  const int cache_pixs = dec->width_ * num_rows;
+  const int start_row = dec->last_row_;
  const int end_row = start_row + num_rows;
  const uint32_t* rows_in = rows;
  uint32_t* const rows_out = dec->argb_cache_;
@@ -789,7 +789,8 @@ static void ProcessRows(VP8LDecoder* const dec, int row) {
    VP8Io* const io = dec->io_;
    uint8_t* rows_data = (uint8_t*)dec->argb_cache_;
    const int in_stride = io->width * sizeof(uint32_t);  // in unit of RGBA
-    ApplyInverseTransforms(dec, dec->last_row_, num_rows, rows);
+
+    ApplyInverseTransforms(dec, num_rows, rows);
    if (!SetCropWindow(io, dec->last_row_, row, &rows_data, in_stride)) {
      // Nothing to output (this time).
    } else {
@@ -1192,7 +1193,6 @@ static int DecodeImageData(VP8LDecoder* const dec, uint32_t* const data,
      VP8LFillBitWindow(br);
      dist_code = GetCopyDistance(dist_symbol, br);
      dist = PlaneCodeToDistance(width, dist_code);
-
      if (VP8LIsEndOfStream(br)) break;
      if (src - data < (ptrdiff_t)dist || src_end - src < (ptrdiff_t)length) {
        goto Error;
@@ -1553,7 +1553,7 @@ static void ExtractAlphaRows(VP8LDecoder* const dec, int last_row) {
    const int cache_pixs = width * num_rows_to_process;
    uint8_t* const dst = output + width * cur_row;
    const uint32_t* const src = dec->argb_cache_;
-    ApplyInverseTransforms(dec, cur_row, num_rows_to_process, in);
+    ApplyInverseTransforms(dec, num_rows_to_process, in);
    WebPExtractGreen(src, dst, cache_pixs);
    AlphaApplyFilter(alph_dec,
                     cur_row, cur_row + num_rows_to_process, dst, width);
@@ -37,7 +37,7 @@ struct VP8LTransform {
  int                    bits_;   // subsampling bits defining transform window.
  int                    xsize_;  // transform window X index.
  int                    ysize_;  // transform window Y index.
-  uint32_t*              data_;   // transform data.
+  uint32_t              *data_;   // transform data.
 };

 typedef struct {
@@ -48,23 +48,23 @@ typedef struct {
  int             huffman_mask_;
  int             huffman_subsample_bits_;
  int             huffman_xsize_;
-  uint32_t*       huffman_image_;
+  uint32_t       *huffman_image_;
  int             num_htree_groups_;
-  HTreeGroup*     htree_groups_;
-  HuffmanCode*    huffman_tables_;
+  HTreeGroup     *htree_groups_;
+  HuffmanCode    *huffman_tables_;
 } VP8LMetadata;

 typedef struct VP8LDecoder VP8LDecoder;
 struct VP8LDecoder {
  VP8StatusCode    status_;
  VP8LDecodeState  state_;
-  VP8Io*           io_;
+  VP8Io           *io_;

-  const WebPDecBuffer* output_;    // shortcut to io->opaque->output
+  const WebPDecBuffer *output_;    // shortcut to io->opaque->output

-  uint32_t*        pixels_;        // Internal data: either uint8_t* for alpha
+  uint32_t        *pixels_;        // Internal data: either uint8_t* for alpha
                                   // or uint32_t* for BGRA.
-  uint32_t*        argb_cache_;    // Scratch buffer for temporary BGRA storage.
+  uint32_t        *argb_cache_;    // Scratch buffer for temporary BGRA storage.

  VP8LBitReader    br_;
  int              incremental_;   // if true, incremental decoding is expected
@@ -86,8 +86,8 @@ struct VP8LDecoder {
  // or'd bitset storing the transforms types.
  uint32_t         transforms_seen_;

-  uint8_t*         rescaler_memory;  // Working memory for rescaling work.
-  WebPRescaler*    rescaler;         // Common rescaler for all channels.
+  uint8_t         *rescaler_memory;  // Working memory for rescaling work.
+  WebPRescaler    *rescaler;         // Common rescaler for all channels.
 };

 //------------------------------------------------------------------------------
@@ -24,8 +24,8 @@
 #include "src/webp/format_constants.h"

 #define DMUX_MAJ_VERSION 1
-#define DMUX_MIN_VERSION 1
-#define DMUX_REV_VERSION 0
+#define DMUX_MIN_VERSION 0
+#define DMUX_REV_VERSION 3

 typedef struct {
  size_t start_;        // start location of the data
@@ -1361,8 +1361,7 @@ static void RD4_NEON(uint8_t* dst) {   // Down-right
  const uint32_t J = dst[-1 + 1 * BPS];
  const uint32_t K = dst[-1 + 2 * BPS];
  const uint32_t L = dst[-1 + 3 * BPS];
-  const uint64x1_t LKJI____ =
-      vcreate_u64((uint64_t)L | (K << 8) | (J << 16) | (I << 24));
+  const uint64x1_t LKJI____ = vcreate_u64(L | (K << 8) | (J << 16) | (I << 24));
  const uint64x1_t LKJIXABC = vorr_u64(LKJI____, ____XABC);
  const uint8x8_t KJIXABC_ = vreinterpret_u8_u64(vshr_n_u64(LKJIXABC, 8));
  const uint8x8_t JIXABC__ = vreinterpret_u8_u64(vshr_n_u64(LKJIXABC, 16));
@@ -1428,16 +1427,10 @@ static WEBP_INLINE void DC8_NEON(uint8_t* dst, int do_top, int do_left) {

  if (do_top) {
    const uint8x8_t A = vld1_u8(dst - BPS);  // top row
-#if defined(__aarch64__)
-    const uint16x8_t B = vmovl_u8(A);
-    const uint16_t p2 = vaddvq_u16(B);
-    sum_top = vdupq_n_u16(p2);
-#else
    const uint16x4_t p0 = vpaddl_u8(A);  // cascading summation of the top
    const uint16x4_t p1 = vpadd_u16(p0, p0);
    const uint16x4_t p2 = vpadd_u16(p1, p1);
    sum_top = vcombine_u16(p2, p2);
-#endif
  }

  if (do_left) {
@@ -246,9 +246,9 @@ extern VP8Fdct VP8FTransform2;   // performs two transforms at a time
 extern VP8WHT VP8FTransformWHT;
 // Predictions
 // *dst is the destination block. *top and *left can be NULL.
-typedef void (*VP8IntraPreds)(uint8_t* dst, const uint8_t* left,
+typedef void (*VP8IntraPreds)(uint8_t *dst, const uint8_t* left,
                              const uint8_t* top);
-typedef void (*VP8Intra4Preds)(uint8_t* dst, const uint8_t* top);
+typedef void (*VP8Intra4Preds)(uint8_t *dst, const uint8_t* top);
 extern VP8Intra4Preds VP8EncPredLuma4;
 extern VP8IntraPreds VP8EncPredLuma16;
 extern VP8IntraPreds VP8EncPredChroma8;
@@ -81,7 +81,7 @@ static WEBP_INLINE uint32_t ClampedAddSubtractHalf(uint32_t c0, uint32_t c1,

 // gcc <= 4.9 on ARM generates incorrect code in Select() when Sub3() is
 // inlined.
-#if defined(__arm__) && defined(__GNUC__) && LOCAL_GCC_VERSION <= 0x409
+#if defined(__arm__) && LOCAL_GCC_VERSION <= 0x409
 # define LOCAL_INLINE __attribute__ ((noinline))
 #else
 # define LOCAL_INLINE WEBP_INLINE
@@ -167,20 +167,15 @@ static uint32_t Predictor13_C(uint32_t left, const uint32_t* const top) {
  return pred;
 }

-static void PredictorAdd0_C(const uint32_t* in, const uint32_t* upper,
-                            int num_pixels, uint32_t* out) {
-  int x;
-  (void)upper;
-  for (x = 0; x < num_pixels; ++x) out[x] = VP8LAddPixels(in[x], ARGB_BLACK);
-}
+GENERATE_PREDICTOR_ADD(Predictor0_C, PredictorAdd0_C)
 static void PredictorAdd1_C(const uint32_t* in, const uint32_t* upper,
                            int num_pixels, uint32_t* out) {
  int i;
  uint32_t left = out[-1];
-  (void)upper;
  for (i = 0; i < num_pixels; ++i) {
    out[i] = left = VP8LAddPixels(in[i], left);
  }
+  (void)upper;
 }
 GENERATE_PREDICTOR_ADD(Predictor2_C, PredictorAdd2_C)
 GENERATE_PREDICTOR_ADD(Predictor3_C, PredictorAdd3_C)
@@ -177,7 +177,6 @@ uint32_t VP8LSubPixels(uint32_t a, uint32_t b) {
 static void PREDICTOR_ADD(const uint32_t* in, const uint32_t* upper, \
                          int num_pixels, uint32_t* out) {           \
  int x;                                                             \
-  assert(upper != NULL);                                             \
  for (x = 0; x < num_pixels; ++x) {                                 \
    const uint32_t pred = (PREDICTOR)(out[x - 1], upper + x);        \
    out[x] = VP8LAddPixels(in[x], pred);                             \
@@ -190,7 +189,6 @@ static void PREDICTOR_ADD(const uint32_t* in, const uint32_t* upper, \
 static void PREDICTOR_SUB(const uint32_t* in, const uint32_t* upper, \
                          int num_pixels, uint32_t* out) {           \
  int x;                                                             \
-  assert(upper != NULL);                                             \
  for (x = 0; x < num_pixels; ++x) {                                 \
    const uint32_t pred = (PREDICTOR)(in[x - 1], upper + x);         \
    out[x] = VP8LSubPixels(in[x], pred);                             \
@@ -455,9 +455,8 @@ static void PredictorSub0_SSE2(const uint32_t* in, const uint32_t* upper,
    _mm_storeu_si128((__m128i*)&out[i], res);
  }
  if (i != num_pixels) {
-    VP8LPredictorsSub_C[0](in + i, NULL, num_pixels - i, out + i);
+    VP8LPredictorsSub_C[0](in + i, upper + i, num_pixels - i, out + i);
  }
-  (void)upper;
 }

 #define GENERATE_PREDICTOR_1(X, IN)                                           \
@@ -191,9 +191,8 @@ static void PredictorAdd0_SSE2(const uint32_t* in, const uint32_t* upper,
    _mm_storeu_si128((__m128i*)&out[i], res);
  }
  if (i != num_pixels) {
-    VP8LPredictorsAdd_C[0](in + i, NULL, num_pixels - i, out + i);
+    VP8LPredictorsAdd_C[0](in + i, upper + i, num_pixels - i, out + i);
  }
-  (void)upper;
 }

 // Predictor1: left.
@@ -576,9 +576,9 @@ static void FUNC_NAME(const uint8_t* top_y, const uint8_t* bot_y,        \
  const uint32_t l_uv = ((cur_u[0]) | ((cur_v[0]) << 16));               \
  const uint32_t uv0 = (3 * tl_uv + l_uv + 0x00020002u) >> 2;            \
  const uint8_t* ptop_y = &top_y[1];                                     \
-  uint8_t* ptop_dst = top_dst + XSTEP;                                   \
+  uint8_t *ptop_dst = top_dst + XSTEP;                                   \
  const uint8_t* pbot_y = &bot_y[1];                                     \
-  uint8_t* pbot_dst = bot_dst + XSTEP;                                   \
+  uint8_t *pbot_dst = bot_dst + XSTEP;                                   \
                                                                         \
  FUNC(top_y[0], uv0 & 0xff, (uv0 >> 16), top_dst);                      \
  if (bot_y != NULL) {                                                   \
@@ -58,8 +58,8 @@
 } while (0)

 // Turn the macro into a function for reducing code-size when non-critical
-static void Upsample16Pixels_NEON(const uint8_t* r1, const uint8_t* r2,
-                                  uint8_t* out) {
+static void Upsample16Pixels_NEON(const uint8_t *r1, const uint8_t *r2,
+                                  uint8_t *out) {
  UPSAMPLE_16PIXELS(r1, r2, out);
 }

@@ -190,14 +190,14 @@ static const int16_t kCoeffs1[4] = { 19077, 26149, 6419, 13320 };
 }

 #define NEON_UPSAMPLE_FUNC(FUNC_NAME, FMT, XSTEP)                       \
-static void FUNC_NAME(const uint8_t* top_y, const uint8_t* bottom_y,    \
-                      const uint8_t* top_u, const uint8_t* top_v,       \
-                      const uint8_t* cur_u, const uint8_t* cur_v,       \
-                      uint8_t* top_dst, uint8_t* bottom_dst, int len) { \
+static void FUNC_NAME(const uint8_t *top_y, const uint8_t *bottom_y,    \
+                      const uint8_t *top_u, const uint8_t *top_v,       \
+                      const uint8_t *cur_u, const uint8_t *cur_v,       \
+                      uint8_t *top_dst, uint8_t *bottom_dst, int len) { \
  int block;                                                            \
  /* 16 byte aligned array to cache reconstructed u and v */            \
  uint8_t uv_buf[2 * 32 + 15];                                          \
-  uint8_t* const r_uv = (uint8_t*)((uintptr_t)(uv_buf + 15) & ~15);     \
+  uint8_t *const r_uv = (uint8_t*)((uintptr_t)(uv_buf + 15) & ~15);     \
  const int uv_len = (len + 1) >> 1;                                    \
  /* 9 pixels must be read-able for each block */                       \
  const int num_blocks = (uv_len - 1) >> 3;                             \
@@ -641,7 +641,7 @@ static void HistogramAnalyzeEntropyBin(VP8LHistogramSet* const image_histo,
 // Merges some histograms with same bin_id together if it's advantageous.
 // Sets the remaining histograms to NULL.
 static void HistogramCombineEntropyBin(VP8LHistogramSet* const image_histo,
-                                       int* num_used,
+                                       int *num_used,
                                       const uint16_t* const clusters,
                                       uint16_t* const cluster_mappings,
                                       VP8LHistogram* cur_combo,
@@ -29,15 +29,11 @@
 #define USE_INVERSE_ALPHA_TABLE

 #ifdef WORDS_BIGENDIAN
-// uint32_t 0xff000000 is 0xff,00,00,00 in memory
-#define CHANNEL_OFFSET(i) (i)
+#define ALPHA_OFFSET 0   // uint32_t 0xff000000 is 0xff,00,00,00 in memory
 #else
-// uint32_t 0xff000000 is 0x00,00,00,ff in memory
-#define CHANNEL_OFFSET(i) (3-(i))
+#define ALPHA_OFFSET 3   // uint32_t 0xff000000 is 0x00,00,00,ff in memory
 #endif

-#define ALPHA_OFFSET CHANNEL_OFFSET(0)
-
 //------------------------------------------------------------------------------
 // Detection of non-trivial transparency

@@ -1001,10 +997,10 @@ static int PictureARGBToYUVA(WebPPicture* picture, WebPEncCSP colorspace,
    return WebPEncodingSetError(picture, VP8_ENC_ERROR_INVALID_CONFIGURATION);
  } else {
    const uint8_t* const argb = (const uint8_t*)picture->argb;
-    const uint8_t* const a = argb + CHANNEL_OFFSET(0);
-    const uint8_t* const r = argb + CHANNEL_OFFSET(1);
-    const uint8_t* const g = argb + CHANNEL_OFFSET(2);
-    const uint8_t* const b = argb + CHANNEL_OFFSET(3);
+    const uint8_t* const a = argb + (0 ^ ALPHA_OFFSET);
+    const uint8_t* const r = argb + (1 ^ ALPHA_OFFSET);
+    const uint8_t* const g = argb + (2 ^ ALPHA_OFFSET);
+    const uint8_t* const b = argb + (3 ^ ALPHA_OFFSET);

    picture->colorspace = WEBP_YUV420;
    return ImportYUVAFromRGBA(r, g, b, a, 4, 4 * picture->argb_stride,
@@ -1054,7 +1050,7 @@ int WebPPictureYUVAToARGB(WebPPicture* picture) {
    const int height = picture->height;
    const int argb_stride = 4 * picture->argb_stride;
    uint8_t* dst = (uint8_t*)picture->argb;
-    const uint8_t* cur_u = picture->u, *cur_v = picture->v, *cur_y = picture->y;
+    const uint8_t *cur_u = picture->u, *cur_v = picture->v, *cur_y = picture->y;
    WebPUpsampleLinePairFunc upsample =
        WebPGetLinePairConverter(ALPHA_OFFSET > 0);

@@ -31,8 +31,8 @@ extern "C" {

 // version numbers
 #define ENC_MAJ_VERSION 1
-#define ENC_MIN_VERSION 1
-#define ENC_REV_VERSION 0
+#define ENC_MIN_VERSION 0
+#define ENC_REV_VERSION 3

 enum { MAX_LF_LEVELS = 64,       // Maximum loop filter level
       MAX_VARIABLE_LEVEL = 67,  // last (inclusive) level with variable cost
@@ -249,7 +249,7 @@ typedef struct {
  int           percent0_;         // saved initial progress percent

  DError        left_derr_;        // left error diffusion (u/v)
-  DError*       top_derr_;         // top diffusion error - NULL if disabled
+  DError       *top_derr_;         // top diffusion error - NULL if disabled

  uint8_t* y_left_;    // left luma samples (addressable from index -1 to 15).
  uint8_t* u_left_;    // left u samples (addressable from index -1 to 7)
@@ -28,8 +28,8 @@ extern "C" {
 // Defines and constants.

 #define MUX_MAJ_VERSION 1
-#define MUX_MIN_VERSION 1
-#define MUX_REV_VERSION 0
+#define MUX_MIN_VERSION 0
+#define MUX_REV_VERSION 3

 // Chunk object.
 typedef struct WebPChunk WebPChunk;
@@ -100,7 +100,7 @@ static int MuxImageParse(const WebPChunk* const chunk, int copy_data,
                         WebPMuxImage* const wpi) {
  const uint8_t* bytes = chunk->data_.bytes;
  size_t size = chunk->data_.size;
-  const uint8_t* const last = (bytes == NULL) ? NULL : bytes + size;
+  const uint8_t* const last = bytes + size;
  WebPChunk subchunk;
  size_t subchunk_size;
  WebPChunk** unknown_chunk_list = &wpi->unknown_;
@@ -26,7 +26,7 @@ extern "C" {

 // Main color cache struct.
 typedef struct {
-  uint32_t* colors_;  // color entries
+  uint32_t *colors_;  // color entries
  int hash_shift_;    // Hash shift: 32 - hash_bits_.
  int hash_bits_;
 } VP8LColorCache;
@@ -73,7 +73,7 @@ typedef struct {
 #endif

 static int pthread_create(pthread_t* const thread, const void* attr,
-                          unsigned int (__stdcall* start)(void*), void* arg) {
+                          unsigned int (__stdcall *start)(void*), void* arg) {
  (void)attr;
 #ifdef USE_CREATE_THREAD
  *thread = CreateThread(NULL,   /* lpThreadAttributes */
@@ -216,14 +216,9 @@ void WebPSafeFree(void* const ptr) {
  free(ptr);
 }

-// Public API functions.
-
-void* WebPMalloc(size_t size) {
-  return WebPSafeMalloc(1, size);
-}
-
+// Public API function.
 void WebPFree(void* ptr) {
-  WebPSafeFree(ptr);
+  free(ptr);
 }

 //------------------------------------------------------------------------------
@@ -20,7 +20,7 @@
 extern "C" {
 #endif

-#define WEBP_DECODER_ABI_VERSION 0x0209    // MAJOR(8b) + MINOR(8b)
+#define WEBP_DECODER_ABI_VERSION 0x0208    // MAJOR(8b) + MINOR(8b)

 // Note: forward declaring enumerations is not allowed in (strict) C and C++,
 // the types are left here for reference.
@@ -91,6 +91,9 @@ WEBP_EXTERN uint8_t* WebPDecodeYUV(const uint8_t* data, size_t data_size,
                                   uint8_t** u, uint8_t** v,
                                   int* stride, int* uv_stride);

+// Releases memory returned by the WebPDecode*() functions above.
+WEBP_EXTERN void WebPFree(void* ptr);
+
 // These five functions are variants of the above ones, that decode the image
 // directly into a pre-allocated buffer 'output_buffer'. The maximum storage
 // available in this buffer is indicated by 'output_buffer_size'. If this
@@ -20,7 +20,7 @@
 extern "C" {
 #endif

-#define WEBP_ENCODER_ABI_VERSION 0x020f    // MAJOR(8b) + MINOR(8b)
+#define WEBP_ENCODER_ABI_VERSION 0x020e    // MAJOR(8b) + MINOR(8b)

 // Note: forward declaring enumerations is not allowed in (strict) C and C++,
 // the types are left here for reference.
@@ -79,6 +79,9 @@ WEBP_EXTERN size_t WebPEncodeLosslessBGRA(const uint8_t* bgra,
                                          int width, int height, int stride,
                                          uint8_t** output);

+// Releases memory returned by the WebPEncode*() functions above.
+WEBP_EXTERN void WebPFree(void* ptr);
+
 //------------------------------------------------------------------------------
 // Coding parameters

@@ -303,7 +306,7 @@ struct WebPPicture {
  // YUV input (mostly used for input to lossy compression)
  WebPEncCSP colorspace;     // colorspace: should be YUV420 for now (=Y'CbCr).
  int width, height;         // dimensions (less or equal to WEBP_MAX_DIMENSION)
-  uint8_t* y, *u, *v;        // pointers to luma/chroma planes.
+  uint8_t *y, *u, *v;        // pointers to luma/chroma planes.
  int y_stride, uv_stride;   // luma/chroma strides.
  uint8_t* a;                // pointer to the alpha plane
  int a_stride;              // stride of the alpha plane
@@ -347,7 +350,7 @@ struct WebPPicture {
  uint32_t pad3[3];       // padding for later use

  // Unused for now
-  uint8_t* pad4, *pad5;
+  uint8_t *pad4, *pad5;
  uint32_t pad6[8];       // padding for later use

  // PRIVATE FIELDS
@@ -57,7 +57,7 @@ extern "C" {
  WebPMuxGetChunk(mux, "ICCP", &icc_profile);
  // ... (Consume icc_data).
  WebPMuxDelete(mux);
-  WebPFree(data);
+  free(data);
 */

 // Note: forward declaring enumerations is not allowed in (strict) C and C++,
@@ -245,7 +245,7 @@ WEBP_EXTERN WebPMuxError WebPMuxPushFrame(
    WebPMux* mux, const WebPMuxFrameInfo* frame, int copy_data);

 // Gets the nth frame from the mux object.
-// The content of 'frame->bitstream' is allocated using WebPMalloc(), and NOT
+// The content of 'frame->bitstream' is allocated using malloc(), and NOT
 // owned by the 'mux' object. It MUST be deallocated by the caller by calling
 // WebPDataClear().
 // nth=0 has a special meaning - last position.
@@ -376,10 +376,10 @@ WEBP_EXTERN WebPMuxError WebPMuxNumChunks(const WebPMux* mux,
 // Assembles all chunks in WebP RIFF format and returns in 'assembled_data'.
 // This function also validates the mux object.
 // Note: The content of 'assembled_data' will be ignored and overwritten.
-// Also, the content of 'assembled_data' is allocated using WebPMalloc(), and
-// NOT owned by the 'mux' object. It MUST be deallocated by the caller by
-// calling WebPDataClear(). It's always safe to call WebPDataClear() upon
-// return, even in case of error.
+// Also, the content of 'assembled_data' is allocated using malloc(), and NOT
+// owned by the 'mux' object. It MUST be deallocated by the caller by calling
+// WebPDataClear(). It's always safe to call WebPDataClear() upon return,
+// even in case of error.
 // Parameters:
 //   mux - (in/out) object whose chunks are to be assembled
 //   assembled_data - (out) assembled WebP data
@@ -14,6 +14,7 @@
 #ifndef WEBP_WEBP_MUX_TYPES_H_
 #define WEBP_WEBP_MUX_TYPES_H_

+#include <stdlib.h>  // free()
 #include <string.h>  // memset()
 #include "./types.h"

@@ -55,7 +56,6 @@ typedef enum WebPMuxAnimBlend {

 // Data type used to describe 'raw' data, e.g., chunk data
 // (ICC profile, metadata) and WebP compressed image data.
-// 'bytes' memory must be allocated using WebPMalloc() and such.
 struct WebPData {
  const uint8_t* bytes;
  size_t size;
@@ -68,11 +68,11 @@ static WEBP_INLINE void WebPDataInit(WebPData* webp_data) {
  }
 }

-// Clears the contents of the 'webp_data' object by calling WebPFree().
-// Does not deallocate the object itself.
+// Clears the contents of the 'webp_data' object by calling free(). Does not
+// deallocate the object itself.
 static WEBP_INLINE void WebPDataClear(WebPData* webp_data) {
  if (webp_data != NULL) {
-    WebPFree((void*)webp_data->bytes);
+    free((void*)webp_data->bytes);
    WebPDataInit(webp_data);
  }
 }
@@ -83,7 +83,7 @@ static WEBP_INLINE int WebPDataCopy(const WebPData* src, WebPData* dst) {
  if (src == NULL || dst == NULL) return 0;
  WebPDataInit(dst);
  if (src->bytes != NULL && src->size != 0) {
-    dst->bytes = (uint8_t*)WebPMalloc(src->size);
+    dst->bytes = (uint8_t*)malloc(src->size);
    if (dst->bytes == NULL) return 0;
    memcpy((void*)dst->bytes, src->bytes, src->size);
    dst->size = src->size;
@@ -7,7 +7,7 @@
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
-//  Common types + memory wrappers
+//  Common types
 //
 // Author: Skal (pascal.massimino@gmail.com)

@@ -49,20 +49,4 @@ typedef long long int int64_t;
 // Macro to check ABI compatibility (same major revision number)
 #define WEBP_ABI_IS_INCOMPATIBLE(a, b) (((a) >> 8) != ((b) >> 8))

-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Allocates 'size' bytes of memory. Returns NULL upon error. Memory
-// must be deallocated by calling WebPFree(). This function is made available
-// by the core 'libwebp' library.
-WEBP_EXTERN void* WebPMalloc(size_t size);
-
-// Releases memory returned by the WebPDecode*() functions (from decode.h).
-WEBP_EXTERN void WebPFree(void* ptr);
-
-#ifdef __cplusplus
-}    // extern "C"
-#endif
-
 #endif  // WEBP_WEBP_TYPES_H_
@@ -60,7 +60,6 @@
 #include "ImathNamespace.h"

 #include <iostream>
-#include <algorithm>

 IMATH_INTERNAL_NAMESPACE_HEADER_ENTER

@@ -1,15 +1,15 @@
 #Cross compile TBB from source
-project(tbb CXX)
+project(tbb)

 if (WIN32 AND NOT ARM)
  message(FATAL_ERROR "BUILD_TBB option supports Windows on ARM only!\nUse regular official TBB build instead of the BUILD_TBB option!")
 endif()

-ocv_update(OPENCV_TBB_RELEASE "v2020.1")
-ocv_update(OPENCV_TBB_RELEASE_MD5 "734f335d06ee80a7d4a20cc0da734c59")
+ocv_update(OPENCV_TBB_RELEASE "v2020.0")
+ocv_update(OPENCV_TBB_RELEASE_MD5 "5858dd01ec007c139d5d178b21e06dae")
 ocv_update(OPENCV_TBB_FILENAME "${OPENCV_TBB_RELEASE}.tar.gz")
 string(REGEX REPLACE "^v" "" OPENCV_TBB_RELEASE_ "${OPENCV_TBB_RELEASE}")
-#ocv_update(OPENCV_TBB_SUBDIR ...)
+ocv_update(OPENCV_TBB_SUBDIR "tbb-${OPENCV_TBB_RELEASE_}")

 set(tbb_src_dir "${OpenCV_BINARY_DIR}/3rdparty/tbb")
 ocv_download(FILENAME ${OPENCV_TBB_FILENAME}
@@ -25,16 +25,6 @@ ocv_download(FILENAME ${OPENCV_TBB_FILENAME}
 if(NOT res)
  return()
 endif()
-if(OPENCV_TBB_SUBDIR)
-  # use current value
-  ocv_assert(EXISTS "${tbb_src_dir}/${OPENCV_TBB_SUBDIR}")
-elseif(EXISTS "${tbb_src_dir}/oneTBB-${OPENCV_TBB_RELEASE_}")
-  set(OPENCV_TBB_SUBDIR "oneTBB-${OPENCV_TBB_RELEASE_}")
-elseif(EXISTS "${tbb_src_dir}/tbb-${OPENCV_TBB_RELEASE_}")
-  set(OPENCV_TBB_SUBDIR "oneTBB-${OPENCV_TBB_RELEASE_}")
-else()
-  message(FATAL_ERROR "TBB: Can't configure TBB. Specify OPENCV_TBB_SUBDIR through command-line.")
-endif()
 set(tbb_src_dir "${tbb_src_dir}/${OPENCV_TBB_SUBDIR}")

 ocv_include_directories("${tbb_src_dir}/include"
@@ -46,11 +36,11 @@ file(GLOB lib_srcs "${tbb_src_dir}/src/tbb/*.cpp")
 file(GLOB lib_hdrs "${tbb_src_dir}/src/tbb/*.h")
 list(APPEND lib_srcs "${tbb_src_dir}/src/rml/client/rml_tbb.cpp")
 ocv_list_filterout(lib_srcs "${tbb_src_dir}/src/tbb/tbbbind.cpp")  # hwloc.h requirement
-ocv_list_filterout(lib_srcs "${tbb_src_dir}/src/tbb/tbb_bind.cpp")  # hwloc.h requirement 2020.1+

 if (WIN32)
  add_definitions(/D__TBB_DYNAMIC_LOAD_ENABLED=0
                  /D__TBB_BUILD=1
+                  /DTBB_SUPPRESS_DEPRECATED_MESSAGES=1
                  /DTBB_NO_LEGACY=1
                  /D_UNICODE
                  /DUNICODE
@@ -109,11 +99,7 @@ configure_file("${CMAKE_CURRENT_SOURCE_DIR}/${tbb_version_file}.cmakein" "${CMAK
 list(APPEND TBB_SOURCE_FILES "${CMAKE_CURRENT_BINARY_DIR}/${tbb_version_file}")

 add_library(tbb ${TBB_SOURCE_FILES})
-target_compile_definitions(tbb PUBLIC
-    TBB_USE_GCC_BUILTINS=1
-    __TBB_GCC_BUILTIN_ATOMICS_PRESENT=1
-    TBB_SUPPRESS_DEPRECATED_MESSAGES=1
-)
+target_compile_definitions(tbb PUBLIC TBB_USE_GCC_BUILTINS=1 __TBB_GCC_BUILTIN_ATOMICS_PRESENT=1)
 target_include_directories(tbb SYSTEM PUBLIC $<BUILD_INTERFACE:${tbb_src_dir}/include>
    PRIVATE "${CMAKE_CURRENT_BINARY_DIR}"
 )
@@ -56,10 +56,6 @@ if(POLICY CMP0056)
  cmake_policy(SET CMP0056 NEW)  # try_compile(): link flags
 endif()

-if(POLICY CMP0066)
-  cmake_policy(SET CMP0066 NEW)  # CMake 3.7: try_compile(): use per-config flags, like CMAKE_CXX_FLAGS_RELEASE
-endif()
-
 if(POLICY CMP0067)
  cmake_policy(SET CMP0067 NEW)  # CMake 3.8: try_compile(): honor language standard variables (like C++11)
 endif()
@@ -72,9 +68,6 @@ if(POLICY CMP0075)
  cmake_policy(SET CMP0075 NEW)  # CMake 3.12+: Include file check macros honor `CMAKE_REQUIRED_LIBRARIES`
 endif()

-if(POLICY CMP0077)
-  cmake_policy(SET CMP0077 NEW)  # CMake 3.13+: option() honors normal variables.
-endif()

 #
 # Configure OpenCV CMake hooks
@@ -285,12 +278,9 @@ OCV_OPTION(WITH_INF_ENGINE "Include Intel Inference Engine support" OFF
 OCV_OPTION(WITH_NGRAPH "Include nGraph support" WITH_INF_ENGINE
  VISIBLE_IF TRUE
  VERIFY TARGET ngraph::ngraph)
-OCV_OPTION(WITH_JASPER "Include JPEG2K support (Jasper)" ON
+OCV_OPTION(WITH_JASPER "Include JPEG2K support" ON
  VISIBLE_IF NOT IOS
  VERIFY HAVE_JASPER)
-OCV_OPTION(WITH_OPENJPEG "Include JPEG2K support (OpenJPEG)" ON
-  VISIBLE_IF NOT IOS
-  VERIFY HAVE_OPENJPEG)
 OCV_OPTION(WITH_JPEG "Include JPEG support" ON
  VISIBLE_IF TRUE
  VERIFY HAVE_JPEG)
@@ -429,9 +419,6 @@ OCV_OPTION(WITH_QUIRC "Include library QR-code decoding" ON
 OCV_OPTION(WITH_ANDROID_MEDIANDK "Use Android Media NDK for Video I/O (Android)" (ANDROID_NATIVE_API_LEVEL GREATER 20)
  VISIBLE_IF ANDROID
  VERIFY HAVE_ANDROID_MEDIANDK)
-OCV_OPTION(WITH_TENGINE "Include Arm Inference Tengine support" OFF
-  VISIBLE_IF (ARM OR AARCH64) AND (UNIX OR ANDROID) AND NOT IOS
-  VERIFY HAVE_TENGINE)

 # OpenCV build components
 # ===================================================
@@ -687,9 +674,6 @@ include(cmake/OpenCVFindLibsVideo.cmake)
 include(cmake/OpenCVFindLibsPerf.cmake)
 include(cmake/OpenCVFindLAPACK.cmake)
 include(cmake/OpenCVFindProtobuf.cmake)
-if(WITH_TENGINE)
-  include(cmake/OpenCVFindTengine.cmake)
-endif()

 # ----------------------------------------------------------------------------
 #  Detect other 3rd-party libraries/tools
@@ -805,13 +789,9 @@ endif()

 foreach(hal ${OpenCV_HAL})
  if(hal STREQUAL "carotene")
-    if(";${CPU_BASELINE_FINAL};" MATCHES ";NEON;")
-      add_subdirectory(3rdparty/carotene/hal)
-      ocv_hal_register(CAROTENE_HAL_LIBRARIES CAROTENE_HAL_HEADERS CAROTENE_HAL_INCLUDE_DIRS)
-      list(APPEND OpenCV_USED_HAL "carotene (ver ${CAROTENE_HAL_VERSION})")
-    else()
-      message(STATUS "Carotene: NEON is not available, disabling carotene...")
-    endif()
+    add_subdirectory(3rdparty/carotene/hal)
+    ocv_hal_register(CAROTENE_HAL_LIBRARIES CAROTENE_HAL_HEADERS CAROTENE_HAL_INCLUDE_DIRS)
+    list(APPEND OpenCV_USED_HAL "carotene (ver ${CAROTENE_HAL_VERSION})")
  elseif(hal STREQUAL "openvx")
    add_subdirectory(3rdparty/openvx)
    ocv_hal_register(OPENVX_HAL_LIBRARIES OPENVX_HAL_HEADERS OPENVX_HAL_INCLUDE_DIRS)
@@ -946,11 +926,11 @@ endif()
 # for UNIX it does not make sense as LICENSE and readme will be part of the package automatically
 if(ANDROID OR NOT UNIX)
  install(FILES ${OPENCV_LICENSE_FILE}
-        PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
+        PERMISSIONS OWNER_READ GROUP_READ WORLD_READ
        DESTINATION ./ COMPONENT libs)
  if(OPENCV_README_FILE)
    install(FILES ${OPENCV_README_FILE}
-            PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
+            PERMISSIONS OWNER_READ GROUP_READ WORLD_READ
            DESTINATION ./ COMPONENT libs)
  endif()
 endif()
@@ -1062,9 +1042,6 @@ string(STRIP "${OPENCV_COMPILER_STR}" OPENCV_COMPILER_STR)
 status("")
 status("  C/C++:")
 status("    Built as dynamic libs?:" BUILD_SHARED_LIBS THEN YES ELSE NO)
-if(DEFINED CMAKE_CXX_STANDARD AND CMAKE_CXX_STANDARD)
-  status("    C++ standard:"           "${CMAKE_CXX_STANDARD}")
-endif()
 status("    C++ Compiler:"           ${OPENCV_COMPILER_STR})
 status("    C++ flags (Release):"    ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_RELEASE})
 status("    C++ flags (Debug):"      ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_DEBUG})
@@ -1252,12 +1229,8 @@ if(WITH_TIFF OR HAVE_TIFF)
  status("    TIFF:" TIFF_FOUND THEN "${TIFF_LIBRARY} (ver ${TIFF_VERSION} / ${TIFF_VERSION_STRING})" ELSE "build (ver ${TIFF_VERSION} - ${TIFF_VERSION_STRING})")
 endif()

-if(HAVE_OPENJPEG)
-  status("    JPEG 2000:" "OpenJPEG (ver ${OPENJPEG_MAJOR_VERSION}.${OPENJPEG_MINOR_VERSION}.${OPENJPEG_BUILD_VERSION})")
-elseif(HAVE_JASPER)
-  status("    JPEG 2000:" JASPER_FOUND THEN "${JASPER_LIBRARY} (ver ${JASPER_VERSION_STRING})" ELSE "build Jasper (ver ${JASPER_VERSION_STRING})")
-elseif(WITH_OPENJPEG OR WITH_JASPER)
-  status("    JPEG 2000:" "NO")
+if(WITH_JASPER OR HAVE_JASPER)
+  status("    JPEG 2000:" JASPER_FOUND THEN "${JASPER_LIBRARY} (ver ${JASPER_VERSION_STRING})" ELSE "build (ver ${JASPER_VERSION_STRING})")
 endif()

 if(WITH_OPENEXR OR HAVE_OPENEXR)
@@ -1426,10 +1399,6 @@ if(WITH_VA_INTEL OR HAVE_VA_INTEL)
  status("    Intel VA-API/OpenCL:"  HAVE_VA_INTEL       THEN "YES (OpenCL: ${VA_INTEL_IOCL_ROOT})" ELSE NO)
 endif()

-if(WITH_TENGINE OR HAVE_TENGINE)
-  status("    Tengine:"      HAVE_TENGINE     THEN "YES (${TENGINE_LIBRARIES})" ELSE NO)
-endif()
-
 if(WITH_LAPACK OR HAVE_LAPACK)
  status("    Lapack:"      HAVE_LAPACK     THEN "YES (${LAPACK_LIBRARIES})" ELSE NO)
 endif()
@@ -13,7 +13,7 @@ Copyright (C) 2009-2016, NVIDIA Corporation, all rights reserved.
 Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
 Copyright (C) 2015-2016, OpenCV Foundation, all rights reserved.
 Copyright (C) 2015-2016, Itseez Inc., all rights reserved.
-Copyright (C) 2019-2020, Xperience AI, all rights reserved.
+Copyright (C) 2019, Xperience AI, all rights reserved.
 Third party copyrights are property of their respective owners.

 Redistribution and use in source and binary forms, with or without modification,
@@ -1,8 +1,6 @@
 add_definitions(-D__OPENCV_BUILD=1)
 add_definitions(-D__OPENCV_APPS=1)

-string(REPLACE "," ";" OPENCV_INSTALL_APPS_LIST "${OPENCV_INSTALL_APPS_LIST}")  # support comma-separated list (,) too
-
 # Unified function for creating OpenCV applications:
 #   ocv_add_application(tgt [MODULES <m1> [<m2> ...]] SRCS <src1> [<src2> ...])
 function(ocv_add_application the_target)
@@ -27,14 +25,12 @@ function(ocv_add_application the_target)
    set_target_properties(${the_target} PROPERTIES FOLDER "applications")
  endif()

-  if(NOT INSTALL_CREATE_DISTRIB
-      OR (OPENCV_INSTALL_APPS_LIST STREQUAL "all" OR ";${OPENCV_INSTALL_APPS_LIST};" MATCHES ";${the_target};")
-  )
-    install(TARGETS ${the_target} RUNTIME DESTINATION ${OPENCV_BIN_INSTALL_PATH} COMPONENT dev)
-  elseif(INSTALL_CREATE_DISTRIB)
+  if(INSTALL_CREATE_DISTRIB)
    if(BUILD_SHARED_LIBS)
      install(TARGETS ${the_target} RUNTIME DESTINATION ${OPENCV_BIN_INSTALL_PATH} CONFIGURATIONS Release COMPONENT dev)
    endif()
+  else()
+    install(TARGETS ${the_target} RUNTIME DESTINATION ${OPENCV_BIN_INSTALL_PATH} COMPONENT dev)
  endif()
 endfunction()

@@ -1078,8 +1078,8 @@ void cvCreateTrainingSamples( const char* filename,
                icvPlaceDistortedSample( sample, inverse, maxintensitydev,
                    maxxangle, maxyangle, maxzangle,
                    0   /* nonzero means placing image without cut offs */,
-                    0.0 /* nonzero adds random shifting                  */,
-                    0.0 /* nonzero adds random scaling                   */,
+                    0.0 /* nozero adds random shifting                  */,
+                    0.0 /* nozero adds random scaling                   */,
                    &data );

                if( showsamples )
@@ -80,7 +80,7 @@ namespace calib
        cv::Size boardSize;
        int charucoDictName;
        int calibrationStep;
-        float charucoSquareLength, charucoMarkerSize;
+        float charucoSquareLenght, charucoMarkerSize;
        float captureDelay;
        float squareSize;
        float templDst;
@@ -1,7 +1,7 @@
 <?xml version="1.0"?>
 <opencv_storage>
 <charuco_dict>0</charuco_dict>
-<charuco_square_length>200</charuco_square_length>
+<charuco_square_lenght>200</charuco_square_lenght>
 <charuco_marker_size>100</charuco_marker_size>
 <calibration_step>1</calibration_step>
 <max_frames_num>30</max_frames_num>
@@ -273,7 +273,7 @@ CalibProcessor::CalibProcessor(cv::Ptr<calibrationData> data, captureParameters
 #ifdef HAVE_OPENCV_ARUCO
        mArucoDictionary = cv::aruco::getPredefinedDictionary(
                    cv::aruco::PREDEFINED_DICTIONARY_NAME(capParams.charucoDictName));
-        mCharucoBoard = cv::aruco::CharucoBoard::create(mBoardSize.width, mBoardSize.height, capParams.charucoSquareLength,
+        mCharucoBoard = cv::aruco::CharucoBoard::create(mBoardSize.width, mBoardSize.height, capParams.charucoSquareLenght,
                                                        capParams.charucoMarkerSize, mArucoDictionary);
 #endif
        break;
@@ -181,7 +181,7 @@ int main(int argc, char** argv)
                            cv::aruco::getPredefinedDictionary(cv::aruco::PREDEFINED_DICTIONARY_NAME(capParams.charucoDictName));
                    cv::Ptr<cv::aruco::CharucoBoard> charucoboard =
                                cv::aruco::CharucoBoard::create(capParams.boardSize.width, capParams.boardSize.height,
-                                                                capParams.charucoSquareLength, capParams.charucoMarkerSize, dictionary);
+                                                                capParams.charucoSquareLenght, capParams.charucoMarkerSize, dictionary);
                    globalData->totalAvgErr =
                            cv::aruco::calibrateCameraCharuco(globalData->allCharucoCorners, globalData->allCharucoIds,
                                                           charucoboard, globalData->imageSize,
@@ -37,10 +37,7 @@ bool calib::parametersController::loadFromFile(const std::string &inputFileName)
    }

    readFromNode(reader["charuco_dict"], mCapParams.charucoDictName);
-    if (readFromNode(reader["charuco_square_lenght"], mCapParams.charucoSquareLength)) {
-        std::cout << "DEPRECATION: Parameter 'charuco_square_lenght' has been deprecated (typo). Use 'charuco_square_length' instead." << std::endl;
-    }
-    readFromNode(reader["charuco_square_length"], mCapParams.charucoSquareLength);
+    readFromNode(reader["charuco_square_lenght"], mCapParams.charucoSquareLenght);
    readFromNode(reader["charuco_marker_size"], mCapParams.charucoMarkerSize);
    readFromNode(reader["camera_resolution"], mCapParams.cameraResolution);
    readFromNode(reader["calibration_step"], mCapParams.calibrationStep);
@@ -54,7 +51,7 @@ bool calib::parametersController::loadFromFile(const std::string &inputFileName)
    bool retValue =
            checkAssertion(mCapParams.charucoDictName >= 0, "Dict name must be >= 0") &&
            checkAssertion(mCapParams.charucoMarkerSize > 0, "Marker size must be positive") &&
-            checkAssertion(mCapParams.charucoSquareLength > 0, "Square size must be positive") &&
+            checkAssertion(mCapParams.charucoSquareLenght > 0, "Square size must be positive") &&
            checkAssertion(mCapParams.minFramesNum > 1, "Minimal number of frames for calibration < 1") &&
            checkAssertion(mCapParams.calibrationStep > 0, "Calibration step must be positive") &&
            checkAssertion(mCapParams.maxFramesNum > mCapParams.minFramesNum, "maxFramesNum < minFramesNum") &&
@@ -122,7 +119,7 @@ bool calib::parametersController::loadFromParser(cv::CommandLineParser &parser)
        mCapParams.board = chAruco;
        mCapParams.boardSize = cv::Size(6, 8);
        mCapParams.charucoDictName = 0;
-        mCapParams.charucoSquareLength = 200;
+        mCapParams.charucoSquareLenght = 200;
        mCapParams.charucoMarkerSize = 100;
    }
    else {
@@ -45,7 +45,7 @@ protected:
    };
    std::vector<Feature> features;

-    cv::Mat normSum; //for normalization calculation (L1 or L2)
+    cv::Mat normSum; //for nomalization calculation (L1 or L2)
    std::vector<cv::Mat> hist;
 };

@@ -70,7 +70,7 @@ inline float CvHOGEvaluator::Feature::calc( const std::vector<cv::Mat>& _hists,

    const float *pnormSum = _normSum.ptr<float>((int)y);
    normFactor = (float)(pnormSum[fastRect[0].p0] - pnormSum[fastRect[1].p1] - pnormSum[fastRect[2].p2] + pnormSum[fastRect[3].p3]);
-    res = (res > 0.001f) ? ( res / (normFactor + 0.001f) ) : 0.f; //for cutting negative values, which appear due to floating precision
+    res = (res > 0.001f) ? ( res / (normFactor + 0.001f) ) : 0.f; //for cutting negative values, which apper due to floating precision

    return res;
 }
@@ -14,11 +14,6 @@
 #include <windows.h>
 #endif

-// defined in core/private.hpp
-namespace cv {
-CV_EXPORTS const char* currentParallelFramework();
-}
-
 static void dumpHWFeatures(bool showAll = false)
 {
    std::cout << "OpenCV's HW features list:" << std::endl;
@@ -39,16 +34,6 @@ static void dumpHWFeatures(bool showAll = false)
    std::cout << "Total available: " << count << std::endl;
 }

-static void dumpParallelFramework()
-{
-    const char* parallelFramework = cv::currentParallelFramework();
-    if (parallelFramework)
-    {
-        int threads = cv::getNumThreads();
-        std::cout << "Parallel framework: " << parallelFramework << " (nthreads=" << threads << ")" << std::endl;
-    }
-}
-
 int main(int argc, const char** argv)
 {
    CV_TRACE_FUNCTION();
@@ -62,7 +47,6 @@ int main(int argc, const char** argv)
        "{ verbose v      |      | show build configuration log }"
        "{ opencl         |      | show information about OpenCL (available platforms/devices, default selected device) }"
        "{ hw             |      | show detected HW features (see cv::checkHardwareSupport() function). Use --hw=0 to show available features only }"
-        "{ threads        |      | show configured parallel framework and number of active threads }"
    );

    if (parser.has("help"))
@@ -89,17 +73,10 @@ int main(int argc, const char** argv)
    {
        dumpHWFeatures(parser.get<bool>("hw"));
    }
-
-    if (parser.has("threads"))
-    {
-        dumpParallelFramework();
-    }
-
 #else
    std::cout << cv::getBuildInformation().c_str() << std::endl;
    cv::dumpOpenCLInformation();
    dumpHWFeatures();
-    dumpParallelFramework();
    MessageBoxA(NULL, "Check console window output", "OpenCV(" CV_VERSION ")", MB_ICONINFORMATION | MB_OK);
 #endif

@@ -64,3 +64,12 @@ else()
    endif()
  endforeach(flag_var)
 endif()
+
+if(CMAKE_VERSION VERSION_GREATER "2.8.6")
+  include(ProcessorCount)
+  ProcessorCount(N)
+  if(NOT N EQUAL 0)
+    SET(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS}   /MP${N} ")
+    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP${N} ")
+  endif()
+endif()
@@ -153,10 +153,6 @@ if(CV_GCC OR CV_CLANG)
    if(CV_GCC AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
      add_extra_compiler_option(-Wno-missing-field-initializers)  # GCC 4.x emits warnings about {}, fixed in GCC 5+
    endif()
-    if(CV_CLANG AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 10.0)
-      add_extra_compiler_option(-Wno-deprecated-enum-enum-conversion)
-      add_extra_compiler_option(-Wno-deprecated-anon-enum-enum-conversion)
-    endif()
  endif()
  add_extra_compiler_option(-fdiagnostics-show-option)

@@ -322,21 +318,6 @@ if(PPC64LE)
  endif()
 endif()

-# Apply "-Wl,--as-needed" linker flags: https://github.com/opencv/opencv/issues/7001
-if(NOT OPENCV_SKIP_LINK_AS_NEEDED)
-  if(UNIX AND (NOT APPLE OR NOT CMAKE_VERSION VERSION_LESS "3.2"))
-    set(_option "-Wl,--as-needed")
-    set(_saved_CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS}")
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${_option}")  # requires CMake 3.2+ and CMP0056
-    ocv_check_compiler_flag(CXX "" HAVE_LINK_AS_NEEDED)
-    set(CMAKE_EXE_LINKER_FLAGS "${_saved_CMAKE_EXE_LINKER_FLAGS}")
-    if(HAVE_LINK_AS_NEEDED)
-      set(OPENCV_EXTRA_EXE_LINKER_FLAGS "${OPENCV_EXTRA_EXE_LINKER_FLAGS} ${_option}")
-      set(OPENCV_EXTRA_SHARED_LINKER_FLAGS "${OPENCV_EXTRA_SHARED_LINKER_FLAGS} ${_option}")
-    endif()
-  endif()
-endif()
-
 # combine all "extra" options
 if(NOT OPENCV_SKIP_EXTRA_COMPILER_FLAGS)
  set(CMAKE_C_FLAGS           "${CMAKE_C_FLAGS} ${OPENCV_EXTRA_FLAGS} ${OPENCV_EXTRA_C_FLAGS}")
@@ -448,38 +429,3 @@ if(OPENCV_EXTRA_RPATH_LINK_PATH)
    message(WARNING "OPENCV_EXTRA_RPATH_LINK_PATH may not work properly because CMAKE_EXECUTABLE_RPATH_LINK_CXX_FLAG is not defined (not supported)")
  endif()
 endif()
-
-# Control MSVC /MP flag
-# Input variables: OPENCV_MSVC_PARALLEL (ON,1,2,3,...) + OPENCV_SKIP_MSVC_PARALLEL
-# Details:
-# - https://docs.microsoft.com/en-us/cpp/build/reference/mp-build-with-multiple-processes
-# - https://docs.microsoft.com/en-us/cpp/build/reference/cl-environment-variables
-# - https://gitlab.kitware.com/cmake/cmake/merge_requests/1718/diffs
-if(CMAKE_GENERATOR MATCHES "Visual Studio" AND CMAKE_CXX_COMPILER_ID MATCHES "MSVC|Intel")
-  ocv_check_environment_variables(OPENCV_SKIP_MSVC_PARALLEL)
-  if(OPENCV_SKIP_MSVC_PARALLEL)
-    # nothing
-  elseif(" ${CMAKE_CXX_FLAGS}" MATCHES "/MP")
-    # nothing, already defined in compiler flags
-  elseif(DEFINED ENV{CL} AND " $ENV{CL}" MATCHES "/MP")
-    # nothing, compiler will use CL environment variable
-  elseif(DEFINED ENV{_CL_} AND " $ENV{_CL_}" MATCHES "/MP")
-    # nothing, compiler will use _CL_ environment variable
-  else()
-    ocv_check_environment_variables(OPENCV_MSVC_PARALLEL)
-    set(_mp_value "ON")
-    if(DEFINED OPENCV_MSVC_PARALLEL)
-      set(_mp_value "${OPENCV_MSVC_PARALLEL}")
-    endif()
-    set(OPENCV_MSVC_PARALLEL "${_mp_value}" CACHE STRING "Control MSVC /MP flag")
-    if(_mp_value)
-      if(_mp_value GREATER 0)
-        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /MP${_mp_value}")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP${_mp_value}")
-      else()
-        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /MP")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
-      endif()
-    endif()
-  endif()
-endif()
@@ -192,13 +192,11 @@ if(CMAKE_VERSION VERSION_LESS "3.1")
  endforeach()
 endif()

-if(NOT OPENCV_SKIP_CMAKE_CXX_STANDARD)
-  ocv_update(CMAKE_CXX_STANDARD 11)
-  ocv_update(CMAKE_CXX_STANDARD_REQUIRED TRUE)
-  ocv_update(CMAKE_CXX_EXTENSIONS OFF) # use -std=c++11 instead of -std=gnu++11
-  if(CMAKE_CXX11_COMPILE_FEATURES)
-    set(HAVE_CXX11 ON)
-  endif()
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
+set(CMAKE_CXX_EXTENSIONS OFF) # use -std=c++11 instead of -std=gnu++11
+if(CMAKE_CXX11_COMPILE_FEATURES)
+  set(HAVE_CXX11 ON)
 endif()
 if(NOT HAVE_CXX11)
  ocv_check_compiler_flag(CXX "" HAVE_CXX11 "${OpenCV_SOURCE_DIR}/cmake/checks/cxx11.cpp")
@@ -215,13 +213,7 @@ if(NOT HAVE_CXX11)
  message(FATAL_ERROR "OpenCV 4.x requires C++11")
 endif()

-set(__OPENCV_ENABLE_ATOMIC_LONG_LONG OFF)
-if(HAVE_CXX11 AND (X86 OR X86_64))
-  set(__OPENCV_ENABLE_ATOMIC_LONG_LONG ON)
-endif()
-option(OPENCV_ENABLE_ATOMIC_LONG_LONG "Enable C++ compiler support for atomic<long long>" ${__OPENCV_ENABLE_ATOMIC_LONG_LONG})
-
-if((HAVE_CXX11 AND OPENCV_ENABLE_ATOMIC_LONG_LONG
+if((HAVE_CXX11
        AND NOT MSVC
        AND NOT (X86 OR X86_64)
    AND NOT OPENCV_SKIP_LIBATOMIC_COMPILER_CHECK)
@@ -232,14 +224,9 @@ if((HAVE_CXX11 AND OPENCV_ENABLE_ATOMIC_LONG_LONG
    list(APPEND CMAKE_REQUIRED_LIBRARIES atomic)
    ocv_check_compiler_flag(CXX "" HAVE_CXX_ATOMICS_WITH_LIB "${OpenCV_SOURCE_DIR}/cmake/checks/atomic_check.cpp")
    if(HAVE_CXX_ATOMICS_WITH_LIB)
-      set(HAVE_ATOMIC_LONG_LONG ON)
      list(APPEND OPENCV_LINKER_LIBS atomic)
    else()
-      message(STATUS "Compiler doesn't support std::atomic<long long>")
+      message(FATAL_ERROR "C++11 compiler must support std::atomic")
    endif()
-  else()
-    set(HAVE_ATOMIC_LONG_LONG ON)
  endif()
-else(HAVE_CXX11 AND OPENCV_ENABLE_ATOMIC_LONG_LONG)
-  set(HAVE_ATOMIC_LONG_LONG ${OPENCV_ENABLE_ATOMIC_LONG_LONG})
 endif()
@@ -17,34 +17,10 @@
 # INF_ENGINE_TARGET - set to name of imported library target representing InferenceEngine
 #

-
-macro(ocv_ie_find_extra_libraries find_prefix find_suffix)
-  file(GLOB libraries "${INF_ENGINE_LIB_DIRS}/${find_prefix}inference_engine*${find_suffix}")
-  foreach(full_path IN LISTS libraries)
-    get_filename_component(library "${full_path}" NAME_WE)
-    string(REPLACE "${find_prefix}" "" library "${library}")
-    if(library STREQUAL "inference_engine" OR library STREQUAL "inference_engined")
-      # skip
-    else()
-      add_library(${library} UNKNOWN IMPORTED)
-      set_target_properties(${library} PROPERTIES
-          IMPORTED_LOCATION "${full_path}")
-      list(APPEND custom_libraries ${library})
-    endif()
-  endforeach()
-endmacro()
-
 function(add_custom_ie_build _inc _lib _lib_rel _lib_dbg _msg)
  if(NOT _inc OR NOT (_lib OR _lib_rel OR _lib_dbg))
    return()
  endif()
-  if(NOT _lib)
-    if(_lib_rel)
-      set(_lib "${_lib_rel}")
-    else()
-      set(_lib "${_lib_dbg}")
-    endif()
-  endif()
  add_library(inference_engine UNKNOWN IMPORTED)
  set_target_properties(inference_engine PROPERTIES
    IMPORTED_LOCATION "${_lib}"
@@ -53,34 +29,29 @@ function(add_custom_ie_build _inc _lib _lib_rel _lib_dbg _msg)
    INTERFACE_INCLUDE_DIRECTORIES "${_inc}"
  )

-  set(custom_libraries "")
-  set(__prefixes "${CMAKE_FIND_LIBRARY_PREFIXES}")
-  if(NOT __prefixes)
-    set(__prefixes "_empty_")
+  find_library(ie_builder_custom_lib "inference_engine_nn_builder" PATHS "${INF_ENGINE_LIB_DIRS}" NO_DEFAULT_PATH)
+  if(EXISTS "${ie_builder_custom_lib}")
+    add_library(inference_engine_nn_builder UNKNOWN IMPORTED)
+    set_target_properties(inference_engine_nn_builder PROPERTIES
+      IMPORTED_LOCATION "${ie_builder_custom_lib}"
+    )
  endif()
-  foreach(find_prefix ${__prefixes})
-    if(find_prefix STREQUAL "_empty_")  # foreach doesn't iterate over empty elements
-      set(find_prefix "")
-    endif()
-    foreach(find_suffix ${CMAKE_FIND_LIBRARY_SUFFIXES})
-      ocv_ie_find_extra_libraries("${find_prefix}" "${find_suffix}")
-    endforeach()
-    if(NOT CMAKE_FIND_LIBRARY_SUFFIXES)
-      ocv_ie_find_extra_libraries("${find_prefix}" "")
-    endif()
-  endforeach()

  if(NOT INF_ENGINE_RELEASE VERSION_GREATER "2018050000")
    find_library(INF_ENGINE_OMP_LIBRARY iomp5 PATHS "${INF_ENGINE_OMP_DIR}" NO_DEFAULT_PATH)
    if(NOT INF_ENGINE_OMP_LIBRARY)
      message(WARNING "OpenMP for IE have not been found. Set INF_ENGINE_OMP_DIR variable if you experience build errors.")
+    else()
+      set_target_properties(inference_engine PROPERTIES IMPORTED_LINK_INTERFACE_LIBRARIES "${INF_ENGINE_OMP_LIBRARY}")
    endif()
  endif()
-  if(EXISTS "${INF_ENGINE_OMP_LIBRARY}")
-    set_target_properties(inference_engine PROPERTIES IMPORTED_LINK_INTERFACE_LIBRARIES "${INF_ENGINE_OMP_LIBRARY}")
-  endif()
  set(INF_ENGINE_VERSION "Unknown" CACHE STRING "")
-  set(INF_ENGINE_TARGET "inference_engine;${custom_libraries}" PARENT_SCOPE)
+  set(INF_ENGINE_TARGET inference_engine)
+  if(TARGET inference_engine_nn_builder)
+    list(APPEND INF_ENGINE_TARGET inference_engine_nn_builder)
+    set(_msg "${_msg}, with IE NN Builder API")
+  endif()
+  set(INF_ENGINE_TARGET "${INF_ENGINE_TARGET}" PARENT_SCOPE)
  message(STATUS "Detected InferenceEngine: ${_msg}")
 endfunction()

@@ -95,9 +66,6 @@ endif()

 if(NOT INF_ENGINE_TARGET AND INF_ENGINE_LIB_DIRS AND INF_ENGINE_INCLUDE_DIRS)
  find_path(ie_custom_inc "inference_engine.hpp" PATHS "${INF_ENGINE_INCLUDE_DIRS}" NO_DEFAULT_PATH)
-  if(CMAKE_BUILD_TYPE STREQUAL "Debug")
-    find_library(ie_custom_lib_dbg "inference_engined" PATHS "${INF_ENGINE_LIB_DIRS}" NO_DEFAULT_PATH)  # Win32 and MacOSX
-  endif()
  find_library(ie_custom_lib "inference_engine" PATHS "${INF_ENGINE_LIB_DIRS}" NO_DEFAULT_PATH)
  find_library(ie_custom_lib_rel "inference_engine" PATHS "${INF_ENGINE_LIB_DIRS}/Release" NO_DEFAULT_PATH)
  find_library(ie_custom_lib_dbg "inference_engine" PATHS "${INF_ENGINE_LIB_DIRS}/Debug" NO_DEFAULT_PATH)
@@ -116,9 +84,6 @@ if(NOT INF_ENGINE_TARGET AND _loc)
  endif()
  set(INF_ENGINE_PLATFORM "${INF_ENGINE_PLATFORM_DEFAULT}" CACHE STRING "InferenceEngine platform (library dir)")
  find_path(ie_custom_env_inc "inference_engine.hpp" PATHS "${_loc}/deployment_tools/inference_engine/include" NO_DEFAULT_PATH)
-  if(CMAKE_BUILD_TYPE STREQUAL "Debug")
-    find_library(ie_custom_env_lib_dbg "inference_engined" PATHS "${_loc}/deployment_tools/inference_engine/lib/${INF_ENGINE_PLATFORM}/intel64" NO_DEFAULT_PATH)
-  endif()
  find_library(ie_custom_env_lib "inference_engine" PATHS "${_loc}/deployment_tools/inference_engine/lib/${INF_ENGINE_PLATFORM}/intel64" NO_DEFAULT_PATH)
  find_library(ie_custom_env_lib_rel "inference_engine" PATHS "${_loc}/deployment_tools/inference_engine/lib/intel64/Release" NO_DEFAULT_PATH)
  find_library(ie_custom_env_lib_dbg "inference_engine" PATHS "${_loc}/deployment_tools/inference_engine/lib/intel64/Debug" NO_DEFAULT_PATH)
@@ -78,10 +78,10 @@ if(NOT ${found})
        AND NOT DEFINED ${executable}
    )
      if(NOT OPENCV_SKIP_PYTHON_WARNING)
-        message(WARNING "CMake's 'find_host_package(PythonInterp ${__python_package_version})' found wrong Python version:\n"
+        message(WARNING "CMake's 'find_host_package(PythonInterp ${__python_package_version})' founds wrong Python version:\n"
                        "PYTHON_EXECUTABLE=${PYTHON_EXECUTABLE}\n"
                        "PYTHON_VERSION_STRING=${PYTHON_VERSION_STRING}\n"
-                        "Consider providing the '${executable}' variable via CMake command line or environment variables\n")
+                        "Consider specify '${executable}' variable via CMake command line or environment variables\n")
      endif()
      ocv_clear_vars(PYTHONINTERP_FOUND PYTHON_EXECUTABLE PYTHON_VERSION_STRING PYTHON_VERSION_MAJOR PYTHON_VERSION_MINOR PYTHON_VERSION_PATCH)
      if(NOT CMAKE_VERSION VERSION_LESS "3.12")
@@ -236,10 +236,6 @@ if(DEFINED ENV{OPENCV_IPP_PATH} AND NOT DEFINED IPPROOT)
 endif()

 if(NOT DEFINED IPPROOT)
-  if(APPLE AND NOT IPP_X64)
-    message(STATUS "IPPICV: 32-bit binaries are not supported on Apple platform (MacOSX)")
-    return()
-  endif()
  include("${OpenCV_SOURCE_DIR}/3rdparty/ippicv/ippicv.cmake")
  download_ippicv(ICV_PACKAGE_ROOT)
  if(NOT ICV_PACKAGE_ROOT)
@@ -153,23 +153,8 @@ if(NOT WEBP_VERSION AND WEBP_INCLUDE_DIR)
  endif()
 endif()

-# --- libopenjp2 (optional, check before libjasper) ---
-if(WITH_OPENJPEG)
-  find_package(OpenJPEG QUIET)
-
-  if(NOT OpenJPEG_FOUND OR OPENJPEG_MAJOR_VERSION LESS 2)
-    set(HAVE_OPENJPEG NO)
-    ocv_clear_vars(OPENJPEG_MAJOR_VERSION OPENJPEG_MINOR_VERSION OPENJPEG_BUILD_VERSION OPENJPEG_LIBRARIES OPENJPEG_INCLUDE_DIRS)
-    message(STATUS "Could NOT find OpenJPEG (minimal suitable version: 2.0, recommended version >= 2.3.1)")
-  else()
-    set(HAVE_OPENJPEG YES)
-    message(STATUS "Found OpenJPEG: ${OPENJPEG_LIBRARIES} "
-            "(found version \"${OPENJPEG_MAJOR_VERSION}.${OPENJPEG_MINOR_VERSION}.${OPENJPEG_BUILD_VERSION}\")")
-  endif()
-endif()
-
 # --- libjasper (optional, should be searched after libjpeg) ---
-if(WITH_JASPER AND NOT HAVE_OPENJPEG)
+if(WITH_JASPER)
  if(BUILD_JASPER)
    ocv_clear_vars(JASPER_FOUND)
  else()
@@ -288,4 +273,4 @@ if(WITH_IMGCODEC_PFM)
  set(HAVE_IMGCODEC_PFM ON)
 elseif(DEFINED WITH_IMGCODEC_PFM)
  set(HAVE_IMGCODEC_PFM OFF)
-endif()
+endif()
@@ -25,16 +25,6 @@ if(WITH_IPP)
    elseif(ANDROID AND NOT OPENCV_SKIP_ANDROID_IPP_FIX_2)
      set(CMAKE_SHARED_LINKER_FLAGS "-Wl,-Bsymbolic ${CMAKE_SHARED_LINKER_FLAGS}")
    endif()
-
-    if(OPENCV_FORCE_IPP_EXCLUDE_LIBS
-        OR (HAVE_IPP_ICV
-            AND UNIX AND NOT ANDROID AND NOT APPLE
-            AND (CMAKE_CXX_COMPILER_ID MATCHES "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-        )
-        AND NOT OPENCV_SKIP_IPP_EXCLUDE_LIBS
-    )
-      set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--exclude-libs,libippicv.a -Wl,--exclude-libs,libippiw.a ${CMAKE_SHARED_LINKER_FLAGS}")
-    endif()
  endif()
 endif()

@@ -20,8 +20,6 @@ if(WIN32)
    elseif(MSVC)
        SET(OPENEXR_LIBSEARCH_SUFFIXES Win32/Release Win32 Win32/Debug)
    endif()
-elseif(UNIX)
-    SET(OPENEXR_LIBSEARCH_SUFFIXES ${CMAKE_LIBRARY_ARCHITECTURE})
 endif()

 SET(SEARCH_PATHS
@@ -41,25 +39,6 @@ MACRO(FIND_OPENEXR_LIBRARY LIBRARY_NAME LIBRARY_SUFFIX)
        PATHS "${SEARCH_PATH}/lib" "${SEARCH_PATH}/lib/static")
 ENDMACRO()

-MACRO(ocv_find_openexr LIBRARY_SUFFIX)
-    IF(NOT OPENEXR_FOUND)
-        FIND_OPENEXR_LIBRARY("Half" "${LIBRARY_SUFFIX}")
-        FIND_OPENEXR_LIBRARY("Iex" "${LIBRARY_SUFFIX}")
-        FIND_OPENEXR_LIBRARY("Imath" "${LIBRARY_SUFFIX}")
-        FIND_OPENEXR_LIBRARY("IlmImf" "${LIBRARY_SUFFIX}")
-        FIND_OPENEXR_LIBRARY("IlmThread" "${LIBRARY_SUFFIX}")
-        IF (OPENEXR_INCLUDE_PATH AND OPENEXR_IMATH_LIBRARY AND OPENEXR_ILMIMF_LIBRARY AND OPENEXR_IEX_LIBRARY AND OPENEXR_HALF_LIBRARY AND OPENEXR_ILMTHREAD_LIBRARY)
-            SET(OPENEXR_FOUND TRUE)
-        ELSE()
-            UNSET(OPENEXR_IMATH_LIBRARY)
-            UNSET(OPENEXR_ILMIMF_LIBRARY)
-            UNSET(OPENEXR_IEX_LIBRARY)
-            UNSET(OPENEXR_ILMTHREAD_LIBRARY)
-            UNSET(OPENEXR_HALF_LIBRARY)
-        ENDIF()
-    ENDIF()
-ENDMACRO()
-
 FOREACH(SEARCH_PATH ${SEARCH_PATHS})
    FIND_PATH(OPENEXR_INCLUDE_PATH ImfRgbaFile.h
        PATH_SUFFIXES OpenEXR
@@ -85,14 +64,32 @@ FOREACH(SEARCH_PATH ${SEARCH_PATHS})
        set(OPENEXR_VERSION "${OPENEXR_VERSION_MAJOR}_${OPENEXR_VERSION_MINOR}")
    ENDIF ()

-    ocv_find_openexr("-${OPENEXR_VERSION}")
-    ocv_find_openexr("-${OPENEXR_VERSION}_s")
-    ocv_find_openexr("-${OPENEXR_VERSION}_d")
-    ocv_find_openexr("-${OPEXEXR_VERSION}_s_d")
-    ocv_find_openexr("")
-    ocv_find_openexr("_s")
-    ocv_find_openexr("_d")
-    ocv_find_openexr("_s_d")
+    SET(LIBRARY_SUFFIXES
+        "-${OPENEXR_VERSION}"
+        "-${OPENEXR_VERSION}_s"
+        "-${OPENEXR_VERSION}_d"
+        "-${OPEXEXR_VERSION}_s_d"
+        ""
+        "_s"
+        "_d"
+        "_s_d")
+
+    FOREACH(LIBRARY_SUFFIX ${LIBRARY_SUFFIXES})
+        FIND_OPENEXR_LIBRARY("Half" ${LIBRARY_SUFFIX})
+        FIND_OPENEXR_LIBRARY("Iex" ${LIBRARY_SUFFIX})
+        FIND_OPENEXR_LIBRARY("Imath" ${LIBRARY_SUFFIX})
+        FIND_OPENEXR_LIBRARY("IlmImf" ${LIBRARY_SUFFIX})
+        FIND_OPENEXR_LIBRARY("IlmThread" ${LIBRARY_SUFFIX})
+        IF (OPENEXR_INCLUDE_PATH AND OPENEXR_IMATH_LIBRARY AND OPENEXR_ILMIMF_LIBRARY AND OPENEXR_IEX_LIBRARY AND OPENEXR_HALF_LIBRARY)
+            SET(OPENEXR_FOUND TRUE)
+            BREAK()
+        ENDIF()
+        UNSET(OPENEXR_IMATH_LIBRARY)
+        UNSET(OPENEXR_ILMIMF_LIBRARY)
+        UNSET(OPENEXR_IEX_LIBRARY)
+        UNSET(OPENEXR_ILMTHREAD_LIBRARY)
+        UNSET(OPENEXR_HALF_LIBRARY)
+    ENDFOREACH()

    IF (OPENEXR_FOUND)
        BREAK()
@@ -1,78 +0,0 @@
-# COPYRIGHT
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# License); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# AS IS BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-# Copyright (c) 2020, OPEN AI LAB
-# Author: qtang@openailab.com or https://github.com/BUG1989
-#
-
-# ----------------------------------------------------------------------------
-#  Path for Tengine binaries
-# ----------------------------------------------------------------------------
-set(OPENCV_LIBTENGINE_ROOT_DIR "" CACHE PATH "Path to TENGINE binaries installation")
-
-IF(OPENCV_LIBTENGINE_ROOT_DIR AND NOT BUILD_TENGINE)
-
-	MESSAGE(STATUS "TENGINE:--  Use binaries at ${OPENCV_LIBTENGINE_ROOT_DIR}")
-
-	SET(Tengine_FOUND ON)
-	set(BUILD_TENGINE OFF)
-
-	SET(Tengine_INCLUDE_DIR "${OPENCV_LIBTENGINE_ROOT_DIR}/include" CACHE PATH "TENGINE include dir")
-	SET(Tengine_LIB "${OPENCV_LIBTENGINE_ROOT_DIR}/lib/libtengine.a" CACHE PATH "TENGINE library dir")
-
-ELSE()
-	IF(ANDROID)
-		IF(OPENCV_TENGINE_FORCE_ANDROID)
-			# nothing, use Android
-		ELSEIF(OPENCV_TENGINE_SKIP_ANDROID)
-			set(Tengine_FOUND OFF)
-			set(HAVE_TENGINE FALSE)
-			return()
-		ELSEIF(NOT DEFINED ANDROID_NDK_REVISION)
-			MESSAGE(STATUS "Android NDK version Tengine not support: ANDROID_NDK_REVISION is not defined")
-			set(Tengine_FOUND OFF)
-			set(HAVE_TENGINE FALSE)
-			return()
-		ELSEIF(ANDROID_NDK_REVISION VERSION_LESS 14)
-			MESSAGE(STATUS "Android NDK version Tengine not support: ANDROID_NDK_REVISION=${ANDROID_NDK_REVISION}")
-			set(Tengine_FOUND OFF)
-			set(HAVE_TENGINE FALSE)
-			return()
-		ENDIF()
-	ENDIF()
-	MESSAGE(STATUS "TENGINE:--  Build Tengine from source code. ")
-	include("${OpenCV_SOURCE_DIR}/3rdparty/libtengine/tengine.cmake")
-ENDIF()
-
-IF(NOT Tengine_LIB)
-	SET(Tengine_FOUND OFF)
-	MESSAGE(STATUS "#### Could not find Tengine lib. Turning Tengine_FOUND off")
-ENDIF()
-
-IF (Tengine_FOUND)
-	MESSAGE(STATUS "Found Tengine include: ${Tengine_INCLUDE_DIR}")
-	MESSAGE(STATUS "Found Tengine libraries: ${Tengine_LIB}")
-	set(HAVE_TENGINE 1)
-	set(TENGINE_LIBRARIES    ${Tengine_LIB})
-	set(TENGINE_INCLUDE_DIRS    ${Tengine_INCLUDE_DIR})
-ENDIF (Tengine_FOUND)
-
-MARK_AS_ADVANCED(
-	Tengine_INCLUDE_DIR
-	Tengine_LIB
-)
@@ -2,8 +2,6 @@ if (NOT GENERATE_ABI_DESCRIPTOR)
  return()
 endif()

-set(OPENCV_ABI_SKIP_MODULES_LIST "" CACHE STRING "List of modules to exclude from ABI checker")
-
 set(filename "opencv_abi.xml")
 set(path1 "${CMAKE_BINARY_DIR}/${filename}")

@@ -28,7 +26,6 @@ foreach(mod ${OPENCV_MODULES_BUILD})
  string(REGEX REPLACE "^opencv_" "" mod "${mod}")
  if(NOT OPENCV_MODULE_opencv_${mod}_CLASS STREQUAL "PUBLIC"
      OR NOT "${OPENCV_MODULE_opencv_${mod}_LOCATION}" STREQUAL "${OpenCV_SOURCE_DIR}/modules/${mod}" # opencv_contrib
-      OR ";${mod};" MATCHES ";${OPENCV_ABI_SKIP_MODULES_LIST};"
  )
    # headers
    foreach(h ${OPENCV_MODULE_opencv_${mod}_HEADERS})
@@ -1087,17 +1087,6 @@ macro(ocv_check_dependencies)
  endforeach()
 endmacro()

-################################################################################
-# OpenCV tests
-################################################################################
-
-if(DEFINED OPENCV_BUILD_TEST_MODULES_LIST)
-  string(REPLACE "," ";" OPENCV_BUILD_TEST_MODULES_LIST "${OPENCV_BUILD_TEST_MODULES_LIST}")  # support comma-separated list (,) too
-endif()
-if(DEFINED OPENCV_BUILD_PERF_TEST_MODULES_LIST)
-  string(REPLACE "," ";" OPENCV_BUILD_PERF_TEST_MODULES_LIST "${OPENCV_BUILD_PERF_TEST_MODULES_LIST}")  # support comma-separated list (,) too
-endif()
-
 # auxiliary macro to parse arguments of ocv_add_accuracy_tests and ocv_add_perf_tests commands
 macro(__ocv_parse_test_sources tests_type)
  set(OPENCV_${tests_type}_${the_module}_SOURCES "")
@@ -1126,8 +1115,6 @@ macro(__ocv_parse_test_sources tests_type)
  unset(__currentvar)
 endmacro()

-ocv_check_environment_variables(OPENCV_TEST_EXTRA_CXX_FLAGS_Release)
-
 # this is a command for adding OpenCV performance tests to the module
 # ocv_add_perf_tests(<extra_dependencies>)
 function(ocv_add_perf_tests)
@@ -1138,12 +1125,7 @@ function(ocv_add_perf_tests)
  endif()

  set(perf_path "${CMAKE_CURRENT_LIST_DIR}/perf")
-  if(BUILD_PERF_TESTS AND EXISTS "${perf_path}"
-      AND (NOT DEFINED OPENCV_BUILD_PERF_TEST_MODULES_LIST
-          OR OPENCV_BUILD_PERF_TEST_MODULES_LIST STREQUAL "all"
-          OR ";${OPENCV_BUILD_PERF_TEST_MODULES_LIST};" MATCHES ";${name};"
-      )
-  )
+  if(BUILD_PERF_TESTS AND EXISTS "${perf_path}")
    __ocv_parse_test_sources(PERF ${ARGN})

    # opencv_imgcodecs is required for imread/imwrite
@@ -1228,12 +1210,7 @@ function(ocv_add_accuracy_tests)
  ocv_debug_message("ocv_add_accuracy_tests(" ${ARGN} ")")

  set(test_path "${CMAKE_CURRENT_LIST_DIR}/test")
-  if(BUILD_TESTS AND EXISTS "${test_path}"
-      AND (NOT DEFINED OPENCV_BUILD_TEST_MODULES_LIST
-          OR OPENCV_BUILD_TEST_MODULES_LIST STREQUAL "all"
-          OR ";${OPENCV_BUILD_TEST_MODULES_LIST};" MATCHES ";${name};"
-      )
-  )
+  if(BUILD_TESTS AND EXISTS "${test_path}")
    __ocv_parse_test_sources(TEST ${ARGN})

    # opencv_imgcodecs is required for imread/imwrite
@@ -1302,10 +1279,6 @@ function(ocv_add_accuracy_tests)
        _ocv_add_precompiled_headers(${the_target})
      endif()

-      if(OPENCV_TEST_EXTRA_CXX_FLAGS_Release)
-        target_compile_options(${the_target} PRIVATE "$<$<CONFIG:Release>:${OPENCV_TEST_EXTRA_CXX_FLAGS_Release}>")
-      endif()
-
      ocv_add_test_from_target("${the_target}" "Accuracy" "${the_target}")
    else(OCV_DEPENDENCIES_FOUND)
      # TODO: warn about unsatisfied dependencies
@@ -123,9 +123,10 @@ endif()
 set(STD_OPENCV_LIBS opencv-data)
 set(STD_OPENCV_DEV libopencv-dev)

-foreach(module calib3d core dnn features2d flann gapi highgui
-               imgcodecs imgproc ml objdetect
-               photo stitching ts video videoio)
+foreach(module calib3d core cudaarithm cudabgsegm cudacodec cudafeatures2d cudafilters
+               cudaimgproc cudalegacy cudaobjdetect cudaoptflow cudastereo cudawarping
+               cudev features2d flann hal highgui imgcodecs imgproc ml objdetect ocl
+               photo shape stitching superres ts video videoio videostab viz)
  if(HAVE_opencv_${module})
    list(APPEND STD_OPENCV_LIBS "libopencv-${module}4.0")
    list(APPEND STD_OPENCV_DEV "libopencv-${module}-dev")
@@ -401,9 +401,9 @@ macro(ocv_clear_vars)
 endmacro()

 set(OCV_COMPILER_FAIL_REGEX
-    "argument .* is not valid"                  # GCC 9+ (including support of unicode quotes)
-    "command[- ]line option .* is valid for .* but not for C\\+\\+" # GNU
-    "command[- ]line option .* is valid for .* but not for C" # GNU
+    "argument '.*' is not valid"                # GCC 9+
+    "command line option .* is valid for .* but not for C\\+\\+" # GNU
+    "command line option .* is valid for .* but not for C" # GNU
    "unrecognized .*option"                     # GNU
    "unknown .*option"                          # Clang
    "ignoring unknown option"                   # MSVC
@@ -540,7 +540,7 @@ macro(ocv_check_flag_support lang flag varname base_options)

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

  ocv_check_compiler_flag("${_lang}" "${base_options} ${flag}" ${${varname}} ${ARGN})
 endmacro()
@@ -16,6 +16,6 @@ int main()
 {
    __vector float vf;
    __vector signed int vi;
-    __asm__ __volatile__ ("xvcvsxwsp %x0,%x1" : "=wa" (vf) : "wa" (vi));
+    __asm__ __volatile__ ("xvcvsxwsp %x0,%x1" : "=wf" (vf) : "wa" (vi));
    return 0;
 }
@@ -273,32 +273,6 @@ endif()
 # ==============================================================
 set(OpenCV_LIBRARIES ${OpenCV_LIBS})

-# Require C++11 features for OpenCV modules
-if(CMAKE_VERSION VERSION_LESS "3.1")
-  if(NOT OpenCV_FIND_QUIETLY AND NOT OPENCV_HIDE_WARNING_COMPILE_FEATURES)
-    message(STATUS "OpenCV: CMake version is low (${CMAKE_VERSION}, required 3.1+). Can't enable C++11 features: https://github.com/opencv/opencv/issues/13000")
-  endif()
-else()
-  set(__target opencv_core)
-  if(TARGET opencv_world)
-    set(__target opencv_world)
-  endif()
-  set(__compile_features cxx_std_11)  # CMake 3.8+
-  if(DEFINED OPENCV_COMPILE_FEATURES)
-    set(__compile_features ${OPENCV_COMPILE_FEATURES})  # custom override
-  elseif(CMAKE_VERSION VERSION_LESS "3.8")
-    set(__compile_features cxx_auto_type cxx_rvalue_references cxx_lambdas)
-  endif()
-  if(__compile_features)
-    # Simulate exported result of target_compile_features(opencv_core PUBLIC ...)
-    set_target_properties(${__target} PROPERTIES
-        INTERFACE_COMPILE_FEATURES "${__compile_features}"
-    )
-  endif()
-  unset(__target)
-  unset(__compile_features)
-endif()
-
 #
 # Some macros for samples
 #
@@ -81,7 +81,6 @@
 #cmakedefine HAVE_IPP_IW_LL

 /* JPEG-2000 codec */
-#cmakedefine HAVE_OPENJPEG
 #cmakedefine HAVE_JASPER

 /* IJG JPEG codec */
@@ -13,7 +13,7 @@ OpenCV.js saves images as cv.Mat type. We use HTML canvas element to transfer cv
 or in reverse. The ImageData interface can represent or set the underlying pixel data of an area of a
 canvas element.

-@note Please refer to canvas docs for more details.
+@sa Please refer to canvas docs for more details.

 First, create an ImageData obj from canvas:
@code{.js}
@@ -145,7 +145,7 @@ no child, parent is contour-3. So array is [-1,-1,-1,3].
 And this is the final guy, Mr.Perfect. It retrieves all the contours and creates a full family
 hierarchy list. **It even tells, who is the grandpa, father, son, grandson and even beyond... :)**.

-For example, I took above image, rewrite the code for cv.RETR_TREE, reorder the contours as per the
+For examle, I took above image, rewrite the code for cv.RETR_TREE, reorder the contours as per the
 result given by OpenCV and analyze it. Again, red letters give the contour number and green letters
 give the hierarchy order.

@@ -83,7 +83,7 @@ use 7x6 grid. (Normally a chess board has 8x8 squares and 7x7 internal corners).
 corner points and retval which will be True if pattern is obtained. These corners will be placed in
 an order (from left-to-right, top-to-bottom)

-@note This function may not be able to find the required pattern in all the images. So, one good option
+@sa This function may not be able to find the required pattern in all the images. So, one good option
 is to write the code such that, it starts the camera and check each frame for required pattern. Once
 the pattern is obtained, find the corners and store it in a list. Also, provide some interval before
 reading next frame so that we can adjust our chess board in different direction. Continue this
@@ -91,7 +91,7 @@ process until the required number of good patterns are obtained. Even in the exa
 are not sure how many images out of the 14 given are good.  Thus, we must read all the images and take only the good
 ones.

-@note Instead of chess board, we can alternatively use a circular grid.  In this case, we must use the function
+@sa Instead of chess board, we can alternatively use a circular grid.  In this case, we must use the function
 **cv.findCirclesGrid()** to find the pattern. Fewer images are sufficient to perform camera calibration using a circular grid.

 Once we find the corners, we can increase their accuracy using **cv.cornerSubPix()**. We can also
@@ -17,7 +17,7 @@ In short, we found locations of some parts of an object in another cluttered ima
 is sufficient to find the object exactly on the trainImage.

 For that, we can use a function from calib3d module, ie **cv.findHomography()**. If we pass the set
-of points from both the images, it will find the perspective transformation of that object. Then we
+of points from both the images, it will find the perpective transformation of that object. Then we
 can use **cv.perspectiveTransform()** to find the object. It needs atleast four correct points to
 find the transformation.

@@ -68,7 +68,7 @@ Now we set a condition that atleast 10 matches (defined by MIN_MATCH_COUNT) are
 find the object. Otherwise simply show a message saying not enough matches are present.

 If enough matches are found, we extract the locations of matched keypoints in both the images. They
-are passed to find the perspective transformation. Once we get this 3x3 transformation matrix, we use
+are passed to find the perpective transformation. Once we get this 3x3 transformation matrix, we use
 it to transform the corners of queryImage to corresponding points in trainImage. Then we draw it.
@code{.py}
 if len(good)>MIN_MATCH_COUNT:
@@ -7,25 +7,25 @@ Goal
 In this chapter,

 -   We will understand the concepts behind Harris Corner Detection.
-   We will see the following functions: **cv.cornerHarris()**, **cv.cornerSubPix()**
+-   We will see the functions: **cv.cornerHarris()**, **cv.cornerSubPix()**

 Theory
 ------

-In the last chapter, we saw that corners are regions in the image with large variation in intensity in
+In last chapter, we saw that corners are regions in the image with large variation in intensity in
 all the directions. One early attempt to find these corners was done by **Chris Harris & Mike
 Stephens** in their paper **A Combined Corner and Edge Detector** in 1988, so now it is called
-the Harris Corner Detector. He took this simple idea to a mathematical form. It basically finds the
+Harris Corner Detector. He took this simple idea to a mathematical form. It basically finds the
 difference in intensity for a displacement of \f$(u,v)\f$ in all directions. This is expressed as below:

 \f[E(u,v) = \sum_{x,y} \underbrace{w(x,y)}_\text{window function} \, [\underbrace{I(x+u,y+v)}_\text{shifted intensity}-\underbrace{I(x,y)}_\text{intensity}]^2\f]

-The window function is either a rectangular window or a Gaussian window which gives weights to pixels
+Window function is either a rectangular window or gaussian window which gives weights to pixels
 underneath.

-We have to maximize this function \f$E(u,v)\f$ for corner detection. That means we have to maximize the
-second term. Applying Taylor Expansion to the above equation and using some mathematical steps (please
-refer to any standard text books you like for full derivation), we get the final equation as:
+We have to maximize this function \f$E(u,v)\f$ for corner detection. That means, we have to maximize the
+second term. Applying Taylor Expansion to above equation and using some mathematical steps (please
+refer any standard text books you like for full derivation), we get the final equation as:

 \f[E(u,v) \approx \begin{bmatrix} u & v \end{bmatrix} M \begin{bmatrix} u \\ v \end{bmatrix}\f]

@@ -34,20 +34,20 @@ where
 \f[M = \sum_{x,y} w(x,y) \begin{bmatrix}I_x I_x & I_x I_y \\
                                     I_x I_y & I_y I_y \end{bmatrix}\f]

-Here, \f$I_x\f$ and \f$I_y\f$ are image derivatives in x and y directions respectively. (These can be easily found
-using **cv.Sobel()**).
+Here, \f$I_x\f$ and \f$I_y\f$ are image derivatives in x and y directions respectively. (Can be easily found
+out using **cv.Sobel()**).

-Then comes the main part. After this, they created a score, basically an equation, which
-determines if a window can contain a corner or not.
+Then comes the main part. After this, they created a score, basically an equation, which will
+determine if a window can contain a corner or not.

 \f[R = det(M) - k(trace(M))^2\f]

 where
    -   \f$det(M) = \lambda_1 \lambda_2\f$
    -   \f$trace(M) = \lambda_1 + \lambda_2\f$
-    -   \f$\lambda_1\f$ and \f$\lambda_2\f$ are the eigenvalues of M
+    -   \f$\lambda_1\f$ and \f$\lambda_2\f$ are the eigen values of M

-So the magnitudes of these eigenvalues decide whether a region is a corner, an edge, or flat.
+So the values of these eigen values decide whether a region is corner, edge or flat.

 -   When \f$|R|\f$ is small, which happens when \f$\lambda_1\f$ and \f$\lambda_2\f$ are small, the region is
    flat.
@@ -60,16 +60,16 @@ It can be represented in a nice picture as follows:
 ![image](images/harris_region.jpg)

 So the result of Harris Corner Detection is a grayscale image with these scores. Thresholding for a
-suitable score gives you the corners in the image. We will do it with a simple image.
+suitable give you the corners in the image. We will do it with a simple image.

 Harris Corner Detector in OpenCV
 --------------------------------

-OpenCV has the function **cv.cornerHarris()** for this purpose. Its arguments are:
+OpenCV has the function **cv.cornerHarris()** for this purpose. Its arguments are :

-   **img** - Input image. It should be grayscale and float32 type.
+-   **img** - Input image, it should be grayscale and float32 type.
 -   **blockSize** - It is the size of neighbourhood considered for corner detection
-   **ksize** - Aperture parameter of the Sobel derivative used.
+-   **ksize** - Aperture parameter of Sobel derivative used.
 -   **k** - Harris detector free parameter in the equation.

 See the example below:
@@ -103,12 +103,12 @@ Corner with SubPixel Accuracy

 Sometimes, you may need to find the corners with maximum accuracy. OpenCV comes with a function
 **cv.cornerSubPix()** which further refines the corners detected with sub-pixel accuracy. Below is
-an example. As usual, we need to find the Harris corners first. Then we pass the centroids of these
+an example. As usual, we need to find the harris corners first. Then we pass the centroids of these
 corners (There may be a bunch of pixels at a corner, we take their centroid) to refine them. Harris
 corners are marked in red pixels and refined corners are marked in green pixels. For this function,
 we have to define the criteria when to stop the iteration. We stop it after a specified number of
-iterations or a certain accuracy is achieved, whichever occurs first. We also need to define the size
-of the neighbourhood it searches for corners.
+iteration or a certain accuracy is achieved, whichever occurs first. We also need to define the size
+of neighbourhood it would search for corners.
@code{.py}
 import numpy as np
 import cv2 as cv
@@ -139,7 +139,7 @@ img[res[:,3],res[:,2]] = [0,255,0]

 cv.imwrite('subpixel5.png',img)
@endcode
-Below is the result, where some important locations are shown in the zoomed window to visualize:
+Below is the result, where some important locations are shown in zoomed window to visualize:

 ![image](images/subpixel3.png)

@@ -28,7 +28,7 @@ If it is a greater than a threshold value, it is considered as a corner. If we p
 ![image](images/shitomasi_space.png)

 From the figure, you can see that only when \f$\lambda_1\f$ and \f$\lambda_2\f$ are above a minimum value,
-\f$\lambda_{min}\f$, it is considered as a corner(green region).
+\f$\lambda_{min}\f$, it is conidered as a corner(green region).

 Code
 ----
@@ -132,7 +132,7 @@ A screen-shot of the window will look like this :

 ![image](images/matplotlib_screenshot.jpg)

-@note Plenty of plotting options are available in Matplotlib. Please refer to Matplotlib docs for more
+@sa Plenty of plotting options are available in Matplotlib. Please refer to Matplotlib docs for more
 details. Some, we will see on the way.

 __warning__
@@ -144,7 +144,7 @@ cv.rectangle(img,(x,y),(x+w,y+h),(0,255,0),2)
 ### 7.b. Rotated Rectangle

 Here, bounding rectangle is drawn with minimum area, so it considers the rotation also. The function
-used is **cv.minAreaRect()**. It returns a Box2D structure which contains following details - (
+used is **cv.minAreaRect()**. It returns a Box2D structure which contains following detals - (
 center (x,y), (width, height), angle of rotation ). But to draw this rectangle, we need 4 corners of
 the rectangle. It is obtained by the function **cv.boxPoints()**
@code{.py}
@@ -185,7 +185,7 @@ array([[[ 3, -1,  1, -1],
 And this is the final guy, Mr.Perfect. It retrieves all the contours and creates a full family
 hierarchy list. **It even tells, who is the grandpa, father, son, grandson and even beyond... :)**.

-For example, I took above image, rewrite the code for cv.RETR_TREE, reorder the contours as per the
+For examle, I took above image, rewrite the code for cv.RETR_TREE, reorder the contours as per the
 result given by OpenCV and analyze it. Again, red letters give the contour number and green letters
 give the hierarchy order.

@@ -113,7 +113,7 @@ I got following results:

 See, even image rotation doesn't affect much on this comparison.

-@note [Hu-Moments](http://en.wikipedia.org/wiki/Image_moment#Rotation_invariant_moments) are seven
+@sa [Hu-Moments](http://en.wikipedia.org/wiki/Image_moment#Rotation_invariant_moments) are seven
 moments invariant to translation, rotation and scale. Seventh one is skew-invariant. Those values
 can be found using **cv.HuMoments()** function.

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Alexander Alekhin	4de7015cfd	dnn: prevent unloading of InferenceEngine plugins	2020-01-22 18:46:00 +03:00
Liubov Batanina	d42d34e2ee	Support lrn with SPATIAL_NRM	2020-01-21 12:49:58 +03:00
Dmitry Kurtaev	04d4af1a6d	MVN support through nGraph	2020-01-17 12:11:45 +03:00
Dmitry Kurtaev	cb64fdabb5	Different way to reset Myriad device	2020-01-15 20:01:53 +03:00
Dmitry Kurtaev	8cb0a37336	Wrap custom OpenCV layers to try-catch	2020-01-15 17:52:24 +03:00
Dmitry Kurtaev	aae15a4efa	Fix uninitialized value	2020-01-15 13:01:33 +03:00
Alexander Alekhin	b61b146f0e	dnn: use OpenVINO 2020.1 defines	2020-01-14 16:44:17 +03:00
Dmitry Kurtaev	905c551b7b	ONNX graphs simplifier	2020-01-14 16:44:17 +03:00
Alexander Alekhin	7c4398a0f6	copyright: 2020	2020-01-14 16:22:30 +03:00
Liubov Batanina	b3eb24cd07	Enable acrossSpatial normalizeL2 on Myriad	2020-01-14 16:22:30 +03:00
Dmitry Kurtaev	5b5c2093bb	AddV2 from TensorFlow	2020-01-14 16:22:30 +03:00
Dmitry Kurtaev	010cc2e58a	Sort text TensorFlow graphs	2020-01-14 16:22:30 +03:00
Dmitry Kurtaev	2f23737e66	Disable some tests for Myriad target of nGraph Add lightweight IE hardware targets checks nGraph: Concat with paddings Enable more nGraph tests Restore FP32->FP16 for GPU plugin of IE try to fix buildbot Use lightweight IE targets check only starts from R4	2020-01-14 16:22:30 +03:00
Alexander Alekhin	43cb28bdb5	OpenCV version '-openvino'	2020-01-14 16:22:30 +03:00