gapi(simd): initialize accumulator values

original commit: 99502e99cc
OpenCV version '-openvino'
2026-07-25 21:33:04 +04:00 · 2020-03-30 19:36:30 +03:00 · 2020-03-24 16:17:01 +03:00 · 2020-03-24 16:17:01 +03:00
956 changed files with 5910 additions and 52247 deletions
@@ -24,4 +24,3 @@ bin/
 build
 node_modules
 CMakeSettings.json
-xcuserdata/
@@ -1,8 +1,8 @@
-# Binaries branch name: ffmpeg/master_20200609
-# Binaries were created for OpenCV: 5f3012fc9afbffbf53a38f1468523d3454b3e2f6
-ocv_update(FFMPEG_BINARIES_COMMIT "1df9bf0c0c6c2cf225bd3d8e4cf5985198352454")
-ocv_update(FFMPEG_FILE_HASH_BIN32 "854b3460c435d04277e1f1ecc06cb809")
-ocv_update(FFMPEG_FILE_HASH_BIN64 "3a46d6356220796e044817ae3a21cc31")
+# 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")
 ocv_update(FFMPEG_FILE_HASH_CMAKE "ad57c038ba34b868277ccbe6dd0f9602")

 function(download_win_ffmpeg script_var)
@@ -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 5)
+set(VERSION_REVISION 4)
 set(VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_REVISION})
-set(LIBJPEG_TURBO_VERSION_NUMBER 2000005)
+set(LIBJPEG_TURBO_VERSION_NUMBER 2000004)

 string(TIMESTAMP BUILD "opencv-${OPENCV_VERSION}-libjpeg-turbo")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
@@ -65,8 +65,6 @@ set(JPEG_LIB_VERSION 62)
 # OpenCV
 set(JPEG_LIB_VERSION "${VERSION}-${JPEG_LIB_VERSION}" PARENT_SCOPE)

-set(THREAD_LOCAL "")  # WITH_TURBOJPEG is not used
-
 if(MSVC)
  add_definitions(-W3 -wd4996 -wd4018)
 endif()
@@ -15,9 +15,6 @@
 #endif
 #endif

-/* How to obtain thread-local storage */
-#define THREAD_LOCAL  @THREAD_LOCAL@
-
 /* Define to the full name of this package. */
 #define PACKAGE_NAME  "@CMAKE_PROJECT_NAME@"

@@ -143,7 +143,8 @@ empty_mem_output_buffer(j_compress_ptr cinfo)

  MEMCOPY(nextbuffer, dest->buffer, dest->bufsize);

-  free(dest->newbuffer);
+  if (dest->newbuffer != NULL)
+    free(dest->newbuffer);

  dest->newbuffer = nextbuffer;

@@ -4,7 +4,7 @@
 * This file was part of the Independent JPEG Group's software:
 * Copyright (C) 1991-2012, Thomas G. Lane, Guido Vollbeding.
 * libjpeg-turbo Modifications:
- * Copyright (C) 2010, 2012-2020, D. R. Commander.
+ * Copyright (C) 2010, 2012-2019, D. R. Commander.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
 *
@@ -36,7 +36,7 @@
 */

 #define JCOPYRIGHT \
-  "Copyright (C) 2009-2020 D. R. Commander\n" \
+  "Copyright (C) 2009-2019 D. R. Commander\n" \
  "Copyright (C) 2011-2016 Siarhei Siamashka\n" \
  "Copyright (C) 2015-2016, 2018 Matthieu Darbois\n" \
  "Copyright (C) 2015 Intel Corporation\n" \
@@ -49,4 +49,4 @@
  "Copyright (C) 1991-2016 Thomas G. Lane, Guido Vollbeding"

 #define JCOPYRIGHT_SHORT \
-  "Copyright (C) 1991-2020 The libjpeg-turbo Project and many others"
+  "Copyright (C) 1991-2019 The libjpeg-turbo Project and many others"
@@ -1,7 +1,7 @@
 The Independent JPEG Group's JPEG software
 ==========================================

-README for release 9d of 12-Jan-2020
+README for release 9c of 14-Jan-2018
 ====================================

 This distribution contains the ninth public release of the Independent JPEG
@@ -10,8 +10,8 @@ to use it for any purpose, subject to the conditions under LEGAL ISSUES, below.

 This software is the work of Tom Lane, Guido Vollbeding, Philip Gladstone,
 Bill Allombert, Jim Boucher, Lee Crocker, Bob Friesenhahn, Ben Jackson,
-John Korejwa, Julian Minguillon, Luis Ortiz, George Phillips, Davide Rossi,
-Ge' Weijers, and other members of the Independent JPEG Group.
+Julian Minguillon, Luis Ortiz, George Phillips, Davide Rossi, Ge' Weijers,
+and other members of the Independent JPEG Group.

 IJG is not affiliated with the ISO/IEC JTC1/SC29/WG1 standards committee
 (previously known as JPEG, together with ITU-T SG16).
@@ -115,7 +115,7 @@ with respect to this software, its quality, accuracy, merchantability, or
 fitness for a particular purpose.  This software is provided "AS IS", and you,
 its user, assume the entire risk as to its quality and accuracy.

-This software is copyright (C) 1991-2020, Thomas G. Lane, Guido Vollbeding.
+This software is copyright (C) 1991-2018, Thomas G. Lane, Guido Vollbeding.
 All Rights Reserved except as specified below.

 Permission is hereby granted to use, copy, modify, and distribute this
@@ -152,6 +152,13 @@ The same holds for its supporting scripts (config.guess, config.sub,
 ltmain.sh).  Another support script, install-sh, is copyright by X Consortium
 but is also freely distributable.

+The IJG distribution formerly included code to read and write GIF files.
+To avoid entanglement with the Unisys LZW patent (now expired), GIF reading
+support has been removed altogether, and the GIF writer has been simplified
+to produce "uncompressed GIFs".  This technique does not use the LZW
+algorithm; the resulting GIF files are larger than usual, but are readable
+by all standard GIF decoders.
+

 REFERENCES
 ==========
@@ -239,8 +246,8 @@ ARCHIVE LOCATIONS
 The "official" archive site for this software is www.ijg.org.
 The most recent released version can always be found there in
 directory "files".  This particular version will be archived as
-http://www.ijg.org/files/jpegsrc.v9d.tar.gz, and in Windows-compatible
-"zip" archive format as http://www.ijg.org/files/jpegsr9d.zip.
+http://www.ijg.org/files/jpegsrc.v9c.tar.gz, and in Windows-compatible
+"zip" archive format as http://www.ijg.org/files/jpegsr9c.zip.

 The JPEG FAQ (Frequently Asked Questions) article is a source of some
 general information about JPEG.
@@ -1,55 +1,6 @@
 CHANGE LOG for Independent JPEG Group's JPEG software


-Version 9d  12-Jan-2020
-----------------------
-
-Optimize the optimal Huffman code table generation to produce
-slightly smaller files.  Thank to John Korejwa for suggestion.
-Note: Requires rebuild of testimgp.jpg.
-
-Decoding Huffman: Use default tables if tables are not defined.
-Thank to Simone Azzalin for report (Motion JPEG),
-and to Martin Strunz for hint.
-
-Add sanity check in optimal Huffman code table generation.
-Thank to Adam Farley for suggestion.
-
-rdtarga.c: use read_byte(), with EOF check, instead of getc()
-in read_*_pixel().
-Thank to Chijin Zhou for cjpeg potential vulnerability report.
-
-jmemnobs.c: respect the max_memory_to_use setting in
-jpeg_mem_available() computation.  Thank to Sheng Shu and
-Dongdong She for djpeg potential vulnerability report.
-
-jdarith.c, jdhuff.c: avoid left shift of negative value
-compiler warning in decode_mcu_AC_refine().
-Thank to Indu Bhagat for suggestion.
-
-Add x64 (64-bit) platform support, avoid compiler warnings.
-Thank to Jonathan Potter, Feiyun Wang, and Sheng Shu for suggestion.
-
-Adjust libjpeg version specification for pkg-config file.
-Thank to Chen Chen for suggestion.
-
-Restore GIF read and write support from libjpeg version 6a.
-Thank to Wolfgang Werner (W.W.) Heinz for suggestion.
-
-Improve consistency in raw (downsampled) image data processing mode.
-Thank to Zhongyuan Zhou for hint.
-
-Avoid out of bounds array read (AC derived table pointers)
-in start pass in jdhuff.c.  Thank to Peng Li for report.
-
-Improve code sanity (jdhuff.c).
-Thank to Reza Mirzazade farkhani for reports.
-
-Add jpegtran -drop option; add options to the crop extension and wipe
-to fill the extra area with content from the source image region,
-instead of gray out.
-
-
 Version 9c  14-Jan-2018
 -----------------------

@@ -1,7 +1,7 @@
 /*
 * jcarith.c
 *
- * Developed 1997-2019 by Guido Vollbeding.
+ * Developed 1997-2013 by Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
@@ -181,11 +181,11 @@ finish_pass (j_compress_ptr cinfo)
    if (e->zc)  /* output final pending zero bytes */
      do emit_byte(0x00, cinfo);
      while (--e->zc);
-    emit_byte((int) ((e->c >> 19) & 0xFF), cinfo);
+    emit_byte((e->c >> 19) & 0xFF, cinfo);
    if (((e->c >> 19) & 0xFF) == 0xFF)
      emit_byte(0x00, cinfo);
    if (e->c & 0x7F800L) {
-      emit_byte((int) ((e->c >> 11) & 0xFF), cinfo);
+      emit_byte((e->c >> 11) & 0xFF, cinfo);
      if (((e->c >> 11) & 0xFF) == 0xFF)
 	emit_byte(0x00, cinfo);
    }
@@ -280,8 +280,7 @@ arith_encode (j_compress_ptr cinfo, unsigned char *st, int val)
 	/* Note: The 3 spacer bits in the C register guarantee
 	 * that the new buffer byte can't be 0xFF here
 	 * (see page 160 in the P&M JPEG book). */
-	/* New output byte, might overflow later */
-	e->buffer = (int) (temp & 0xFF);
+	e->buffer = temp & 0xFF;  /* new output byte, might overflow later */
      } else if (temp == 0xFF) {
 	++e->sc;  /* stack 0xFF byte (which might overflow later) */
      } else {
@@ -303,8 +302,7 @@ arith_encode (j_compress_ptr cinfo, unsigned char *st, int val)
 	    emit_byte(0x00, cinfo);
 	  } while (--e->sc);
 	}
-	/* New output byte (can still overflow) */
-	e->buffer = (int) (temp & 0xFF);
+	e->buffer = temp & 0xFF;  /* new output byte (can still overflow) */
      }
      e->c &= 0x7FFFFL;
      e->ct += 8;
@@ -928,8 +926,9 @@ jinit_arith_encoder (j_compress_ptr cinfo)
  arith_entropy_ptr entropy;
  int i;

-  entropy = (arith_entropy_ptr) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(arith_entropy_encoder));
+  entropy = (arith_entropy_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(arith_entropy_encoder));
  cinfo->entropy = &entropy->pub;
  entropy->pub.start_pass = start_pass;
  entropy->pub.finish_pass = finish_pass;
@@ -2,7 +2,7 @@
 * jccolor.c
 *
 * Copyright (C) 1991-1996, Thomas G. Lane.
- * Modified 2011-2019 by Guido Vollbeding.
+ * Modified 2011-2013 by Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
@@ -105,14 +105,14 @@ rgb_ycc_start (j_compress_ptr cinfo)
  /* Allocate and fill in the conversion tables. */
  cconvert->rgb_ycc_tab = rgb_ycc_tab = (INT32 *)
    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-				TABLE_SIZE * SIZEOF(INT32));
+				(TABLE_SIZE * SIZEOF(INT32)));

  for (i = 0; i <= MAXJSAMPLE; i++) {
    rgb_ycc_tab[i+R_Y_OFF] = FIX(0.299) * i;
    rgb_ycc_tab[i+G_Y_OFF] = FIX(0.587) * i;
    rgb_ycc_tab[i+B_Y_OFF] = FIX(0.114) * i   + ONE_HALF;
-    rgb_ycc_tab[i+R_CB_OFF] = (- FIX(0.168735892)) * i;
-    rgb_ycc_tab[i+G_CB_OFF] = (- FIX(0.331264108)) * i;
+    rgb_ycc_tab[i+R_CB_OFF] = (-FIX(0.168735892)) * i;
+    rgb_ycc_tab[i+G_CB_OFF] = (-FIX(0.331264108)) * i;
    /* We use a rounding fudge-factor of 0.5-epsilon for Cb and Cr.
     * This ensures that the maximum output will round to MAXJSAMPLE
     * not MAXJSAMPLE+1, and thus that we don't have to range-limit.
@@ -121,8 +121,8 @@ rgb_ycc_start (j_compress_ptr cinfo)
 /*  B=>Cb and R=>Cr tables are the same
    rgb_ycc_tab[i+R_CR_OFF] = FIX(0.5) * i    + CBCR_OFFSET + ONE_HALF-1;
 */
-    rgb_ycc_tab[i+G_CR_OFF] = (- FIX(0.418687589)) * i;
-    rgb_ycc_tab[i+B_CR_OFF] = (- FIX(0.081312411)) * i;
+    rgb_ycc_tab[i+G_CR_OFF] = (-FIX(0.418687589)) * i;
+    rgb_ycc_tab[i+B_CR_OFF] = (-FIX(0.081312411)) * i;
  }
 }

@@ -131,12 +131,12 @@ rgb_ycc_start (j_compress_ptr cinfo)
 * Convert some rows of samples to the JPEG colorspace.
 *
 * Note that we change from the application's interleaved-pixel format
- * to our internal noninterleaved, one-plane-per-component format.  The
- * input buffer is therefore three times as wide as the output buffer.
+ * to our internal noninterleaved, one-plane-per-component format.
+ * The input buffer is therefore three times as wide as the output buffer.
 *
- * A starting row offset is provided only for the output buffer.  The
- * caller can easily adjust the passed input_buf value to accommodate
- * any row offset required on that side.
+ * A starting row offset is provided only for the output buffer.  The caller
+ * can easily adjust the passed input_buf value to accommodate any row
+ * offset required on that side.
 */

 METHODDEF(void)
@@ -145,8 +145,8 @@ rgb_ycc_convert (j_compress_ptr cinfo,
 		 JDIMENSION output_row, int num_rows)
 {
  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
-  register int r, g, b;
  register INT32 * ctab = cconvert->rgb_ycc_tab;
+  register int r, g, b;
  register JSAMPROW inptr;
  register JSAMPROW outptr0, outptr1, outptr2;
  register JDIMENSION col;
@@ -162,7 +162,6 @@ rgb_ycc_convert (j_compress_ptr cinfo,
      r = GETJSAMPLE(inptr[RGB_RED]);
      g = GETJSAMPLE(inptr[RGB_GREEN]);
      b = GETJSAMPLE(inptr[RGB_BLUE]);
-      inptr += RGB_PIXELSIZE;
      /* If the inputs are 0..MAXJSAMPLE, the outputs of these equations
       * must be too; we do not need an explicit range-limiting operation.
       * Hence the value being shifted is never negative, and we don't
@@ -180,6 +179,7 @@ rgb_ycc_convert (j_compress_ptr cinfo,
      outptr2[col] = (JSAMPLE)
 		((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
 		 >> SCALEBITS);
+      inptr += RGB_PIXELSIZE;
    }
  }
 }
@@ -201,8 +201,8 @@ rgb_gray_convert (j_compress_ptr cinfo,
 		  JDIMENSION output_row, int num_rows)
 {
  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
-  register int r, g, b;
  register INT32 * ctab = cconvert->rgb_ycc_tab;
+  register int r, g, b;
  register JSAMPROW inptr;
  register JSAMPROW outptr;
  register JDIMENSION col;
@@ -215,11 +215,11 @@ rgb_gray_convert (j_compress_ptr cinfo,
      r = GETJSAMPLE(inptr[RGB_RED]);
      g = GETJSAMPLE(inptr[RGB_GREEN]);
      b = GETJSAMPLE(inptr[RGB_BLUE]);
-      inptr += RGB_PIXELSIZE;
      /* Y */
      outptr[col] = (JSAMPLE)
 		((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
 		 >> SCALEBITS);
+      inptr += RGB_PIXELSIZE;
    }
  }
 }
@@ -228,8 +228,8 @@ rgb_gray_convert (j_compress_ptr cinfo,
 /*
 * Convert some rows of samples to the JPEG colorspace.
 * This version handles Adobe-style CMYK->YCCK conversion,
- * where we convert R=1-C, G=1-M, and B=1-Y to YCbCr using the
- * same conversion as above, while passing K (black) unchanged.
+ * where we convert R=1-C, G=1-M, and B=1-Y to YCbCr using the same
+ * conversion as above, while passing K (black) unchanged.
 * We assume rgb_ycc_start has been called.
 */

@@ -239,8 +239,8 @@ cmyk_ycck_convert (j_compress_ptr cinfo,
 		   JDIMENSION output_row, int num_rows)
 {
  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
-  register int r, g, b;
  register INT32 * ctab = cconvert->rgb_ycc_tab;
+  register int r, g, b;
  register JSAMPROW inptr;
  register JSAMPROW outptr0, outptr1, outptr2, outptr3;
  register JDIMENSION col;
@@ -259,7 +259,6 @@ cmyk_ycck_convert (j_compress_ptr cinfo,
      b = MAXJSAMPLE - GETJSAMPLE(inptr[2]);
      /* K passes through as-is */
      outptr3[col] = inptr[3];	/* don't need GETJSAMPLE here */
-      inptr += 4;
      /* If the inputs are 0..MAXJSAMPLE, the outputs of these equations
       * must be too; we do not need an explicit range-limiting operation.
       * Hence the value being shifted is never negative, and we don't
@@ -277,6 +276,7 @@ cmyk_ycck_convert (j_compress_ptr cinfo,
      outptr2[col] = (JSAMPLE)
 		((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
 		 >> SCALEBITS);
+      inptr += 4;
    }
  }
 }
@@ -312,13 +312,13 @@ rgb_rgb1_convert (j_compress_ptr cinfo,
      r = GETJSAMPLE(inptr[RGB_RED]);
      g = GETJSAMPLE(inptr[RGB_GREEN]);
      b = GETJSAMPLE(inptr[RGB_BLUE]);
-      inptr += RGB_PIXELSIZE;
      /* Assume that MAXJSAMPLE+1 is a power of 2, so that the MOD
       * (modulo) operator is equivalent to the bitmask operator AND.
       */
      outptr0[col] = (JSAMPLE) ((r - g + CENTERJSAMPLE) & MAXJSAMPLE);
      outptr1[col] = (JSAMPLE) g;
      outptr2[col] = (JSAMPLE) ((b - g + CENTERJSAMPLE) & MAXJSAMPLE);
+      inptr += RGB_PIXELSIZE;
    }
  }
 }
@@ -335,17 +335,17 @@ grayscale_convert (j_compress_ptr cinfo,
 		   JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
 		   JDIMENSION output_row, int num_rows)
 {
+  int instride = cinfo->input_components;
  register JSAMPROW inptr;
  register JSAMPROW outptr;
-  register JDIMENSION count;
-  register int instride = cinfo->input_components;
+  register JDIMENSION col;
  JDIMENSION num_cols = cinfo->image_width;

  while (--num_rows >= 0) {
    inptr = *input_buf++;
    outptr = output_buf[0][output_row++];
-    for (count = num_cols; count > 0; count--) {
-      *outptr++ = *inptr;	/* don't need GETJSAMPLE() here */
+    for (col = 0; col < num_cols; col++) {
+      outptr[col] = inptr[0];	/* don't need GETJSAMPLE() here */
      inptr += instride;
    }
  }
@@ -396,21 +396,21 @@ null_convert (j_compress_ptr cinfo,
 	      JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
 	      JDIMENSION output_row, int num_rows)
 {
+  int ci;
+  register int nc = cinfo->num_components;
  register JSAMPROW inptr;
  register JSAMPROW outptr;
-  register JDIMENSION count;
-  register int num_comps = cinfo->num_components;
+  register JDIMENSION col;
  JDIMENSION num_cols = cinfo->image_width;
-  int ci;

  while (--num_rows >= 0) {
    /* It seems fastest to make a separate pass for each component. */
-    for (ci = 0; ci < num_comps; ci++) {
+    for (ci = 0; ci < nc; ci++) {
      inptr = input_buf[0] + ci;
      outptr = output_buf[ci][output_row];
-      for (count = num_cols; count > 0; count--) {
+      for (col = 0; col < num_cols; col++) {
 	*outptr++ = *inptr;	/* don't need GETJSAMPLE() here */
-	inptr += num_comps;
+	inptr += nc;
      }
    }
    input_buf++;
@@ -439,8 +439,9 @@ jinit_color_converter (j_compress_ptr cinfo)
 {
  my_cconvert_ptr cconvert;

-  cconvert = (my_cconvert_ptr) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_color_converter));
+  cconvert = (my_cconvert_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_color_converter));
  cinfo->cconvert = &cconvert->pub;
  /* set start_pass to null method until we find out differently */
  cconvert->pub.start_pass = null_method;
@@ -454,11 +455,9 @@ jinit_color_converter (j_compress_ptr cinfo)

  case JCS_RGB:
  case JCS_BG_RGB:
-#if RGB_PIXELSIZE != 3
    if (cinfo->input_components != RGB_PIXELSIZE)
      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
    break;
-#endif /* else share code with YCbCr */

  case JCS_YCbCr:
  case JCS_BG_YCC:
@@ -475,6 +474,7 @@ jinit_color_converter (j_compress_ptr cinfo)
  default:			/* JCS_UNKNOWN can be anything */
    if (cinfo->input_components < 1)
      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    break;
  }

  /* Support color transform only for RGB colorspaces */
@@ -507,18 +507,19 @@ jinit_color_converter (j_compress_ptr cinfo)
  case JCS_BG_RGB:
    if (cinfo->num_components != 3)
      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
-    if (cinfo->in_color_space != cinfo->jpeg_color_space)
+    if (cinfo->in_color_space == cinfo->jpeg_color_space) {
+      switch (cinfo->color_transform) {
+      case JCT_NONE:
+	cconvert->pub.color_convert = rgb_convert;
+	break;
+      case JCT_SUBTRACT_GREEN:
+	cconvert->pub.color_convert = rgb_rgb1_convert;
+	break;
+      default:
+	ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+      }
+    } else
      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    switch (cinfo->color_transform) {
-    case JCT_NONE:
-      cconvert->pub.color_convert = rgb_convert;
-      break;
-    case JCT_SUBTRACT_GREEN:
-      cconvert->pub.color_convert = rgb_rgb1_convert;
-      break;
-    default:
-      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    }
    break;

  case JCS_YCbCr:
@@ -571,9 +572,10 @@ jinit_color_converter (j_compress_ptr cinfo)
  case JCS_CMYK:
    if (cinfo->num_components != 4)
      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
-    if (cinfo->in_color_space != JCS_CMYK)
+    if (cinfo->in_color_space == JCS_CMYK)
+      cconvert->pub.color_convert = null_convert;
+    else
      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    cconvert->pub.color_convert = null_convert;
    break;

  case JCS_YCCK:
@@ -597,5 +599,6 @@ jinit_color_converter (j_compress_ptr cinfo)
 	cinfo->num_components != cinfo->input_components)
      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
    cconvert->pub.color_convert = null_convert;
+    break;
  }
 }
@@ -2,7 +2,7 @@
 * jchuff.c
 *
 * Copyright (C) 1991-1997, Thomas G. Lane.
- * Modified 2006-2019 by Guido Vollbeding.
+ * Modified 2006-2013 by Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
@@ -178,12 +178,13 @@ jpeg_make_c_derived_tbl (j_compress_ptr cinfo, boolean isDC, int tblno,
  htbl =
    isDC ? cinfo->dc_huff_tbl_ptrs[tblno] : cinfo->ac_huff_tbl_ptrs[tblno];
  if (htbl == NULL)
-    htbl = jpeg_std_huff_table((j_common_ptr) cinfo, isDC, tblno);
+    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);

  /* Allocate a workspace if we haven't already done so. */
  if (*pdtbl == NULL)
-    *pdtbl = (c_derived_tbl *) (*cinfo->mem->alloc_small)
-      ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(c_derived_tbl));
+    *pdtbl = (c_derived_tbl *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  SIZEOF(c_derived_tbl));
  dtbl = *pdtbl;
  
  /* Figure C.1: make table of Huffman code length for each symbol */
@@ -1255,88 +1256,22 @@ jpeg_gen_optimal_table (j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[])
  UINT8 bits[MAX_CLEN+1];	/* bits[k] = # of symbols with code length k */
  int codesize[257];		/* codesize[k] = code length of symbol k */
  int others[257];		/* next symbol in current branch of tree */
-  int c1, c2, i, j;
-  UINT8 *p;
+  int c1, c2;
+  int p, i, j;
  long v;

-  freq[256] = 1;		/* make sure 256 has a nonzero count */
-  /* Including the pseudo-symbol 256 in the Huffman procedure guarantees
-   * that no real symbol is given code-value of all ones, because 256
-   * will be placed last in the largest codeword category.
-   * In the symbol list build procedure this element serves as sentinel
-   * for the zero run loop.
-   */
-
-#ifndef DONT_USE_FANCY_HUFF_OPT
-
-  /* Build list of symbols sorted in order of descending frequency */
-  /* This approach has several benefits (thank to John Korejwa for the idea):
-   *     1.
-   * If a codelength category is split during the length limiting procedure
-   * below, the feature that more frequent symbols are assigned shorter
-   * codewords remains valid for the adjusted code.
-   *     2.
-   * To reduce consecutive ones in a Huffman data stream (thus reducing the
-   * number of stuff bytes in JPEG) it is preferable to follow 0 branches
-   * (and avoid 1 branches) as much as possible.  This is easily done by
-   * assigning symbols to leaves of the Huffman tree in order of decreasing
-   * frequency, with no secondary sort based on codelengths.
-   *     3.
-   * The symbol list can be built independently from the assignment of code
-   * lengths by the Huffman procedure below.
-   * Note: The symbol list build procedure must be performed first, because
-   * the Huffman procedure assigning the codelengths clobbers the frequency
-   * counts!
-   */
-
-  /* Here we use the others array as a linked list of nonzero frequencies
-   * to be sorted.  Already sorted elements are removed from the list.
-   */
-
-  /* Building list */
-
-  /* This item does not correspond to a valid symbol frequency and is used
-   * as starting index.
-   */
-  j = 256;
-
-  for (i = 0;; i++) {
-    if (freq[i] == 0)		/* skip zero frequencies */
-      continue;
-    if (i > 255)
-      break;
-    others[j] = i;		/* this symbol value */
-    j = i;			/* previous symbol value */
-  }
-  others[j] = -1;		/* mark end of list */
-
-  /* Sorting list */
-
-  p = htbl->huffval;
-  while ((c1 = others[256]) >= 0) {
-    v = freq[c1];
-    i = c1;			/* first symbol value */
-    j = 256;			/* pseudo symbol value for starting index */
-    while ((c2 = others[c1]) >= 0) {
-      if (freq[c2] > v) {
-	v = freq[c2];
-	i = c2;			/* this symbol value */
-	j = c1;			/* previous symbol value */
-      }
-      c1 = c2;
-    }
-    others[j] = others[i];	/* remove this symbol i from list */
-    *p++ = (UINT8) i;
-  }
-
-#endif /* DONT_USE_FANCY_HUFF_OPT */
-
  /* This algorithm is explained in section K.2 of the JPEG standard */

  MEMZERO(bits, SIZEOF(bits));
  MEMZERO(codesize, SIZEOF(codesize));
  for (i = 0; i < 257; i++)
    others[i] = -1;		/* init links to empty */
+  
+  freq[256] = 1;		/* make sure 256 has a nonzero count */
+  /* Including the pseudo-symbol 256 in the Huffman procedure guarantees
+   * that no real symbol is given code-value of all ones, because 256
+   * will be placed last in the largest codeword category.
+   */

  /* Huffman's basic algorithm to assign optimal code lengths to symbols */

@@ -1366,7 +1301,7 @@ jpeg_gen_optimal_table (j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[])
    /* Done if we've merged everything into one frequency */
    if (c2 < 0)
      break;
-
+    
    /* Else merge the two counts/trees */
    freq[c1] += freq[c2];
    freq[c2] = 0;
@@ -1377,9 +1312,9 @@ jpeg_gen_optimal_table (j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[])
      c1 = others[c1];
      codesize[c1]++;
    }
-
+    
    others[c1] = c2;		/* chain c2 onto c1's tree branch */
-
+    
    /* Increment the codesize of everything in c2's tree branch */
    codesize[c2]++;
    while (others[c2] >= 0) {
@@ -1394,7 +1329,7 @@ jpeg_gen_optimal_table (j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[])
      /* The JPEG standard seems to think that this can't happen, */
      /* but I'm paranoid... */
      if (codesize[i] > MAX_CLEN)
-	ERREXIT(cinfo, JERR_HUFF_CLEN_OUTOFBOUNDS);
+	ERREXIT(cinfo, JERR_HUFF_CLEN_OVERFLOW);

      bits[codesize[i]]++;
    }
@@ -1410,16 +1345,13 @@ jpeg_gen_optimal_table (j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[])
   * shortest nonzero BITS entry is converted into a prefix for two code words
   * one bit longer.
   */
-
+  
  for (i = MAX_CLEN; i > 16; i--) {
    while (bits[i] > 0) {
      j = i - 2;		/* find length of new prefix to be used */
-      while (bits[j] == 0) {
-	if (j == 0)
-	  ERREXIT(cinfo, JERR_HUFF_CLEN_OUTOFBOUNDS);
+      while (bits[j] == 0)
 	j--;
-      }
-
+      
      bits[i] -= 2;		/* remove two symbols */
      bits[i-1]++;		/* one goes in this length */
      bits[j+1] += 2;		/* two new symbols in this length */
@@ -1431,27 +1363,24 @@ jpeg_gen_optimal_table (j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[])
  while (bits[i] == 0)		/* find largest codelength still in use */
    i--;
  bits[i]--;
-
+  
  /* Return final symbol counts (only for lengths 0..16) */
  MEMCOPY(htbl->bits, bits, SIZEOF(htbl->bits));
-
-#ifdef DONT_USE_FANCY_HUFF_OPT
-
+  
  /* Return a list of the symbols sorted by code length */
-  /* Note: Due to the codelength changes made above, it can happen
-   * that more frequent symbols are assigned longer codewords.
+  /* It's not real clear to me why we don't need to consider the codelength
+   * changes made above, but the JPEG spec seems to think this works.
   */
-  p = htbl->huffval;
+  p = 0;
  for (i = 1; i <= MAX_CLEN; i++) {
    for (j = 0; j <= 255; j++) {
      if (codesize[j] == i) {
-	*p++ = (UINT8) j;
+	htbl->huffval[p] = (UINT8) j;
+	p++;
      }
    }
  }

-#endif /* DONT_USE_FANCY_HUFF_OPT */
-
  /* Set sent_table FALSE so updated table will be written to JPEG file. */
  htbl->sent_table = FALSE;
 }
@@ -1471,13 +1400,13 @@ finish_pass_gather (j_compress_ptr cinfo)
  boolean did_dc[NUM_HUFF_TBLS];
  boolean did_ac[NUM_HUFF_TBLS];

+  /* It's important not to apply jpeg_gen_optimal_table more than once
+   * per table, because it clobbers the input frequency counts!
+   */
  if (cinfo->progressive_mode)
    /* Flush out buffered data (all we care about is counting the EOB symbol) */
    emit_eobrun(entropy);

-  /* It's important not to apply jpeg_gen_optimal_table more than once
-   * per table, because it clobbers the input frequency counts!
-   */
  MEMZERO(did_dc, SIZEOF(did_dc));
  MEMZERO(did_ac, SIZEOF(did_ac));

@@ -1546,8 +1475,9 @@ start_pass_huff (j_compress_ptr cinfo, boolean gather_statistics)
 	entropy->pub.encode_mcu = encode_mcu_AC_refine;
 	/* AC refinement needs a correction bit buffer */
 	if (entropy->bit_buffer == NULL)
-	  entropy->bit_buffer = (char *) (*cinfo->mem->alloc_small)
-	    ((j_common_ptr) cinfo, JPOOL_IMAGE, MAX_CORR_BITS * SIZEOF(char));
+	  entropy->bit_buffer = (char *)
+	    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+					MAX_CORR_BITS * SIZEOF(char));
      }
    }

@@ -1575,8 +1505,9 @@ start_pass_huff (j_compress_ptr cinfo, boolean gather_statistics)
 	/* Allocate and zero the statistics tables */
 	/* Note that jpeg_gen_optimal_table expects 257 entries in each table! */
 	if (entropy->dc_count_ptrs[tbl] == NULL)
-	  entropy->dc_count_ptrs[tbl] = (long *) (*cinfo->mem->alloc_small)
-	    ((j_common_ptr) cinfo, JPOOL_IMAGE, 257 * SIZEOF(long));
+	  entropy->dc_count_ptrs[tbl] = (long *)
+	    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+					257 * SIZEOF(long));
 	MEMZERO(entropy->dc_count_ptrs[tbl], 257 * SIZEOF(long));
      } else {
 	/* Compute derived values for Huffman tables */
@@ -1594,8 +1525,9 @@ start_pass_huff (j_compress_ptr cinfo, boolean gather_statistics)
 	if (tbl < 0 || tbl >= NUM_HUFF_TBLS)
 	  ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tbl);
 	if (entropy->ac_count_ptrs[tbl] == NULL)
-	  entropy->ac_count_ptrs[tbl] = (long *) (*cinfo->mem->alloc_small)
-	    ((j_common_ptr) cinfo, JPOOL_IMAGE, 257 * SIZEOF(long));
+	  entropy->ac_count_ptrs[tbl] = (long *)
+	    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+					257 * SIZEOF(long));
 	MEMZERO(entropy->ac_count_ptrs[tbl], 257 * SIZEOF(long));
      } else {
 	jpeg_make_c_derived_tbl(cinfo, FALSE, tbl,
@@ -1624,8 +1556,9 @@ jinit_huff_encoder (j_compress_ptr cinfo)
  huff_entropy_ptr entropy;
  int i;

-  entropy = (huff_entropy_ptr) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(huff_entropy_encoder));
+  entropy = (huff_entropy_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(huff_entropy_encoder));
  cinfo->entropy = &entropy->pub;
  entropy->pub.start_pass = start_pass_huff;

@@ -2,7 +2,7 @@
 * jcmarker.c
 *
 * Copyright (C) 1991-1998, Thomas G. Lane.
- * Modified 2003-2019 by Guido Vollbeding.
+ * Modified 2003-2013 by Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
@@ -471,6 +471,7 @@ emit_adobe_app14 (j_compress_ptr cinfo)
    break;
  default:
    emit_byte(cinfo, 0);	/* Color transform = 0 */
+    break;
  }
 }

@@ -701,8 +702,9 @@ jinit_marker_writer (j_compress_ptr cinfo)
  my_marker_ptr marker;

  /* Create the subobject */
-  marker = (my_marker_ptr) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_marker_writer));
+  marker = (my_marker_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_marker_writer));
  cinfo->marker = &marker->pub;
  /* Initialize method pointers */
  marker->pub.write_file_header = write_file_header;
@@ -2,7 +2,7 @@
 * jcmaster.c
 *
 * Copyright (C) 1991-1997, Thomas G. Lane.
- * Modified 2003-2019 by Guido Vollbeding.
+ * Modified 2003-2017 by Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
@@ -62,7 +62,7 @@ initial_setup (j_compress_ptr cinfo)
  case 5: cinfo->natural_order = jpeg_natural_order5; break;
  case 6: cinfo->natural_order = jpeg_natural_order6; break;
  case 7: cinfo->natural_order = jpeg_natural_order7; break;
-  default: cinfo->natural_order = jpeg_natural_order;
+  default: cinfo->natural_order = jpeg_natural_order; break;
  }

  /* Derive lim_Se from block_size */
@@ -114,24 +114,20 @@ initial_setup (j_compress_ptr cinfo)
     */
    ssize = 1;
 #ifdef DCT_SCALING_SUPPORTED
-    if (! cinfo->raw_data_in)
-      while (cinfo->min_DCT_h_scaled_size * ssize <=
-	     (cinfo->do_fancy_downsampling ? DCTSIZE : DCTSIZE / 2) &&
-	     (cinfo->max_h_samp_factor % (compptr->h_samp_factor * ssize * 2)) ==
-	     0) {
-	ssize = ssize * 2;
-      }
+    while (cinfo->min_DCT_h_scaled_size * ssize <=
+	   (cinfo->do_fancy_downsampling ? DCTSIZE : DCTSIZE / 2) &&
+	   (cinfo->max_h_samp_factor % (compptr->h_samp_factor * ssize * 2)) == 0) {
+      ssize = ssize * 2;
+    }
 #endif
    compptr->DCT_h_scaled_size = cinfo->min_DCT_h_scaled_size * ssize;
    ssize = 1;
 #ifdef DCT_SCALING_SUPPORTED
-    if (! cinfo->raw_data_in)
-      while (cinfo->min_DCT_v_scaled_size * ssize <=
-	     (cinfo->do_fancy_downsampling ? DCTSIZE : DCTSIZE / 2) &&
-	     (cinfo->max_v_samp_factor % (compptr->v_samp_factor * ssize * 2)) ==
-	     0) {
-	ssize = ssize * 2;
-      }
+    while (cinfo->min_DCT_v_scaled_size * ssize <=
+	   (cinfo->do_fancy_downsampling ? DCTSIZE : DCTSIZE / 2) &&
+	   (cinfo->max_v_samp_factor % (compptr->v_samp_factor * ssize * 2)) == 0) {
+      ssize = ssize * 2;
+    }
 #endif
    compptr->DCT_v_scaled_size = cinfo->min_DCT_v_scaled_size * ssize;

@@ -624,8 +620,9 @@ jinit_c_master_control (j_compress_ptr cinfo, boolean transcode_only)
 {
  my_master_ptr master;

-  master = (my_master_ptr) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_comp_master));
+  master = (my_master_ptr)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  SIZEOF(my_comp_master));
  cinfo->master = &master->pub;
  master->pub.prepare_for_pass = prepare_for_pass;
  master->pub.pass_startup = pass_startup;
@@ -2,7 +2,6 @@
 * jcomapi.c
 *
 * Copyright (C) 1994-1997, Thomas G. Lane.
- * Modified 2019 by Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
@@ -105,140 +104,3 @@ jpeg_alloc_huff_table (j_common_ptr cinfo)
  tbl->sent_table = FALSE;	/* make sure this is false in any new table */
  return tbl;
 }
-
-
-/*
- * Set up the standard Huffman tables (cf. JPEG standard section K.3).
- * IMPORTANT: these are only valid for 8-bit data precision!
- * (Would jutils.c be a more reasonable place to put this?)
- */
-
-GLOBAL(JHUFF_TBL *)
-jpeg_std_huff_table (j_common_ptr cinfo, boolean isDC, int tblno)
-{
-  JHUFF_TBL **htblptr, *htbl;
-  const UINT8 *bits, *val;
-  int nsymbols, len;
-
-  static const UINT8 bits_dc_luminance[17] =
-    { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
-  static const UINT8 val_dc_luminance[] =
-    { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
-
-  static const UINT8 bits_dc_chrominance[17] =
-    { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
-  static const UINT8 val_dc_chrominance[] =
-    { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
-
-  static const UINT8 bits_ac_luminance[17] =
-    { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
-  static const UINT8 val_ac_luminance[] =
-    { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
-      0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
-      0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
-      0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
-      0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
-      0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
-      0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
-      0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
-      0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
-      0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
-      0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
-      0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
-      0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
-      0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
-      0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
-      0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
-      0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
-      0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
-      0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
-      0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
-      0xf9, 0xfa };
-
-  static const UINT8 bits_ac_chrominance[17] =
-    { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
-  static const UINT8 val_ac_chrominance[] =
-    { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
-      0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
-      0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
-      0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
-      0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
-      0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
-      0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
-      0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
-      0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
-      0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
-      0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
-      0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
-      0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
-      0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
-      0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
-      0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
-      0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
-      0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
-      0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
-      0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
-      0xf9, 0xfa };
-
-  if (cinfo->is_decompressor) {
-    if (isDC)
-      htblptr = ((j_decompress_ptr) cinfo)->dc_huff_tbl_ptrs;
-    else
-      htblptr = ((j_decompress_ptr) cinfo)->ac_huff_tbl_ptrs;
-  } else {
-    if (isDC)
-      htblptr = ((j_compress_ptr) cinfo)->dc_huff_tbl_ptrs;
-    else
-      htblptr = ((j_compress_ptr) cinfo)->ac_huff_tbl_ptrs;
-  }
-
-  switch (tblno) {
-  case 0:
-    if (isDC) {
-      bits = bits_dc_luminance;
-      val = val_dc_luminance;
-    } else {
-      bits = bits_ac_luminance;
-      val = val_ac_luminance;
-    }
-    break;
-  case 1:
-    if (isDC) {
-      bits = bits_dc_chrominance;
-      val = val_dc_chrominance;
-    } else {
-      bits = bits_ac_chrominance;
-      val = val_ac_chrominance;
-    }
-    break;
-  default:
-    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
-    return NULL; /* avoid compiler warnings for uninitialized variables */
-  }
-
-  if (htblptr[tblno] == NULL)
-    htblptr[tblno] = jpeg_alloc_huff_table(cinfo);
-
-  htbl = htblptr[tblno];
-
-  /* Copy the number-of-symbols-of-each-code-length counts */
-  MEMCOPY(htbl->bits, bits, SIZEOF(htbl->bits));
-
-  /* Validate the counts.  We do this here mainly so we can copy the right
-   * number of symbols from the val[] array, without risking marching off
-   * the end of memory.  jxhuff.c will do a more thorough test later.
-   */
-  nsymbols = 0;
-  for (len = 1; len <= 16; len++)
-    nsymbols += bits[len];
-  if (nsymbols > 256)
-    ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
-
-  if (nsymbols > 0)
-    MEMCOPY(htbl->huffval, val, nsymbols * SIZEOF(UINT8));
-
-  /* Initialize sent_table FALSE so table will be written to JPEG file. */
-  htbl->sent_table = FALSE;
-
-  return htbl;
-}
@@ -2,7 +2,7 @@
 * jcparam.c
 *
 * Copyright (C) 1991-1998, Thomas G. Lane.
- * Modified 2003-2019 by Guido Vollbeding.
+ * Modified 2003-2013 by Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
@@ -162,23 +162,112 @@ jpeg_set_quality (j_compress_ptr cinfo, int quality, boolean force_baseline)


 /*
- * Reset standard Huffman tables
+ * Huffman table setup routines
 */

 LOCAL(void)
-std_huff_tables (j_compress_ptr cinfo)
+add_huff_table (j_compress_ptr cinfo,
+		JHUFF_TBL **htblptr, const UINT8 *bits, const UINT8 *val)
+/* Define a Huffman table */
 {
-  if (cinfo->dc_huff_tbl_ptrs[0] != NULL)
-    (void) jpeg_std_huff_table((j_common_ptr) cinfo, TRUE, 0);
+  int nsymbols, len;

-  if (cinfo->ac_huff_tbl_ptrs[0] != NULL)
-    (void) jpeg_std_huff_table((j_common_ptr) cinfo, FALSE, 0);
+  if (*htblptr == NULL)
+    *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);

-  if (cinfo->dc_huff_tbl_ptrs[1] != NULL)
-    (void) jpeg_std_huff_table((j_common_ptr) cinfo, TRUE, 1);
+  /* Copy the number-of-symbols-of-each-code-length counts */
+  MEMCOPY((*htblptr)->bits, bits, SIZEOF((*htblptr)->bits));

-  if (cinfo->ac_huff_tbl_ptrs[1] != NULL)
-    (void) jpeg_std_huff_table((j_common_ptr) cinfo, FALSE, 1);
+  /* Validate the counts.  We do this here mainly so we can copy the right
+   * number of symbols from the val[] array, without risking marching off
+   * the end of memory.  jchuff.c will do a more thorough test later.
+   */
+  nsymbols = 0;
+  for (len = 1; len <= 16; len++)
+    nsymbols += bits[len];
+  if (nsymbols < 1 || nsymbols > 256)
+    ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+
+  MEMCOPY((*htblptr)->huffval, val, nsymbols * SIZEOF(UINT8));
+
+  /* Initialize sent_table FALSE so table will be written to JPEG file. */
+  (*htblptr)->sent_table = FALSE;
+}
+
+
+LOCAL(void)
+std_huff_tables (j_compress_ptr cinfo)
+/* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
+/* IMPORTANT: these are only valid for 8-bit data precision! */
+{
+  static const UINT8 bits_dc_luminance[17] =
+    { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
+  static const UINT8 val_dc_luminance[] =
+    { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
+  
+  static const UINT8 bits_dc_chrominance[17] =
+    { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
+  static const UINT8 val_dc_chrominance[] =
+    { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
+  
+  static const UINT8 bits_ac_luminance[17] =
+    { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
+  static const UINT8 val_ac_luminance[] =
+    { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
+      0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
+      0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
+      0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
+      0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
+      0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
+      0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
+      0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
+      0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
+      0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+      0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+      0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
+      0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
+      0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
+      0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
+      0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
+      0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
+      0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
+      0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
+      0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
+      0xf9, 0xfa };
+  
+  static const UINT8 bits_ac_chrominance[17] =
+    { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
+  static const UINT8 val_ac_chrominance[] =
+    { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
+      0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
+      0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
+      0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
+      0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
+      0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
+      0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
+      0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
+      0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
+      0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
+      0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
+      0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+      0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
+      0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
+      0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
+      0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
+      0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
+      0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
+      0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
+      0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
+      0xf9, 0xfa };
+  
+  add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[0],
+		 bits_dc_luminance, val_dc_luminance);
+  add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[0],
+		 bits_ac_luminance, val_ac_luminance);
+  add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[1],
+		 bits_dc_chrominance, val_dc_chrominance);
+  add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[1],
+		 bits_ac_chrominance, val_ac_chrominance);
 }


@@ -217,7 +306,7 @@ jpeg_set_defaults (j_compress_ptr cinfo)
  cinfo->data_precision = BITS_IN_JSAMPLE;
  /* Set up two quantization tables using default quality of 75 */
  jpeg_set_quality(cinfo, 75, TRUE);
-  /* Reset standard Huffman tables */
+  /* Set up two Huffman tables */
  std_huff_tables(cinfo);

  /* Initialize default arithmetic coding conditioning */
@@ -1,7 +1,7 @@
 /*
 * jdarith.c
 *
- * Developed 1997-2019 by Guido Vollbeding.
+ * Developed 1997-2015 by Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
@@ -280,7 +280,7 @@ decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
      if ((m = arith_decode(cinfo, st)) != 0) {
 	st = entropy->dc_stats[tbl] + 20;	/* Table F.4: X1 = 20 */
 	while (arith_decode(cinfo, st)) {
-	  if ((m <<= 1) == (int) 0x8000U) {
+	  if ((m <<= 1) == 0x8000) {
 	    WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
 	    entropy->ct = -1;			/* magnitude overflow */
 	    return TRUE;
@@ -370,7 +370,7 @@ decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 	st = entropy->ac_stats[tbl] +
 	     (k <= cinfo->arith_ac_K[tbl] ? 189 : 217);
 	while (arith_decode(cinfo, st)) {
-	  if ((m <<= 1) == (int) 0x8000U) {
+	  if ((m <<= 1) == 0x8000) {
 	    WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
 	    entropy->ct = -1;			/* magnitude overflow */
 	    return TRUE;
@@ -404,8 +404,7 @@ decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 {
  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
  unsigned char *st;
-  JCOEF p1;
-  int blkn;
+  int p1, blkn;

  /* Process restart marker if needed */
  if (cinfo->restart_interval) {
@@ -441,7 +440,7 @@ decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
  JCOEFPTR thiscoef;
  unsigned char *st;
  int tbl, k, kex;
-  JCOEF p1, m1;
+  int p1, m1;
  const int * natural_order;

  /* Process restart marker if needed */
@@ -460,7 +459,7 @@ decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
  tbl = cinfo->cur_comp_info[0]->ac_tbl_no;

  p1 = 1 << cinfo->Al;		/* 1 in the bit position being coded */
-  m1 = -p1;			/* -1 in the bit position being coded */
+  m1 = (-1) << cinfo->Al;	/* -1 in the bit position being coded */

  /* Establish EOBx (previous stage end-of-block) index */
  kex = cinfo->Se;
@@ -556,7 +555,7 @@ decode_mcu (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
      if ((m = arith_decode(cinfo, st)) != 0) {
 	st = entropy->dc_stats[tbl] + 20;	/* Table F.4: X1 = 20 */
 	while (arith_decode(cinfo, st)) {
-	  if ((m <<= 1) == (int) 0x8000U) {
+	  if ((m <<= 1) == 0x8000) {
 	    WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
 	    entropy->ct = -1;			/* magnitude overflow */
 	    return TRUE;
@@ -613,7 +612,7 @@ decode_mcu (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 	  st = entropy->ac_stats[tbl] +
 	       (k <= cinfo->arith_ac_K[tbl] ? 189 : 217);
 	  while (arith_decode(cinfo, st)) {
-	    if ((m <<= 1) == (int) 0x8000U) {
+	    if ((m <<= 1) == 0x8000) {
 	      WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
 	      entropy->ct = -1;			/* magnitude overflow */
 	      return TRUE;
@@ -767,8 +766,9 @@ jinit_arith_decoder (j_decompress_ptr cinfo)
  arith_entropy_ptr entropy;
  int i;

-  entropy = (arith_entropy_ptr) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(arith_entropy_decoder));
+  entropy = (arith_entropy_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(arith_entropy_decoder));
  cinfo->entropy = &entropy->pub;
  entropy->pub.start_pass = start_pass;
  entropy->pub.finish_pass = finish_pass;
@@ -785,9 +785,9 @@ jinit_arith_decoder (j_decompress_ptr cinfo)
  if (cinfo->progressive_mode) {
    /* Create progression status table */
    int *coef_bit_ptr, ci;
-    cinfo->coef_bits = (int (*)[DCTSIZE2]) (*cinfo->mem->alloc_small)
-      ((j_common_ptr) cinfo, JPOOL_IMAGE,
-       cinfo->num_components * DCTSIZE2 * SIZEOF(int));
+    cinfo->coef_bits = (int (*)[DCTSIZE2])
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  cinfo->num_components*DCTSIZE2*SIZEOF(int));
    coef_bit_ptr = & cinfo->coef_bits[0][0];
    for (ci = 0; ci < cinfo->num_components; ci++) 
      for (i = 0; i < DCTSIZE2; i++)
@@ -2,7 +2,7 @@
 * jdatadst.c
 *
 * Copyright (C) 1994-1996, Thomas G. Lane.
- * Modified 2009-2019 by Guido Vollbeding.
+ * Modified 2009-2017 by Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
@@ -46,7 +46,7 @@ typedef struct {
  struct jpeg_destination_mgr pub; /* public fields */

  unsigned char ** outbuffer;	/* target buffer */
-  size_t * outsize;
+  unsigned long * outsize;
  unsigned char * newbuffer;	/* newly allocated buffer */
  JOCTET * buffer;		/* start of buffer */
  size_t bufsize;
@@ -66,8 +66,9 @@ init_destination (j_compress_ptr cinfo)
  my_dest_ptr dest = (my_dest_ptr) cinfo->dest;

  /* Allocate the output buffer --- it will be released when done with image */
-  dest->buffer = (JOCTET *) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, OUTPUT_BUF_SIZE * SIZEOF(JOCTET));
+  dest->buffer = (JOCTET *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  OUTPUT_BUF_SIZE * SIZEOF(JOCTET));

  dest->pub.next_output_byte = dest->buffer;
  dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
@@ -130,7 +131,7 @@ empty_mem_output_buffer (j_compress_ptr cinfo)
  nextbuffer = (JOCTET *) malloc(nextsize);

  if (nextbuffer == NULL)
-    ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 11);
+    ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 10);

  MEMCOPY(nextbuffer, dest->buffer, dest->bufsize);

@@ -203,8 +204,9 @@ jpeg_stdio_dest (j_compress_ptr cinfo, FILE * outfile)
   * sizes may be different.  Caveat programmer.
   */
  if (cinfo->dest == NULL) {	/* first time for this JPEG object? */
-    cinfo->dest = (struct jpeg_destination_mgr *) (*cinfo->mem->alloc_small)
-      ((j_common_ptr) cinfo, JPOOL_PERMANENT, SIZEOF(my_destination_mgr));
+    cinfo->dest = (struct jpeg_destination_mgr *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+				  SIZEOF(my_destination_mgr));
  }

  dest = (my_dest_ptr) cinfo->dest;
@@ -231,7 +233,7 @@ jpeg_stdio_dest (j_compress_ptr cinfo, FILE * outfile)

 GLOBAL(void)
 jpeg_mem_dest (j_compress_ptr cinfo,
-	       unsigned char ** outbuffer, size_t * outsize)
+	       unsigned char ** outbuffer, unsigned long * outsize)
 {
  my_mem_dest_ptr dest;

@@ -242,8 +244,9 @@ jpeg_mem_dest (j_compress_ptr cinfo,
   * can be written to the same buffer without re-executing jpeg_mem_dest.
   */
  if (cinfo->dest == NULL) {	/* first time for this JPEG object? */
-    cinfo->dest = (struct jpeg_destination_mgr *) (*cinfo->mem->alloc_small)
-      ((j_common_ptr) cinfo, JPOOL_PERMANENT, SIZEOF(my_mem_destination_mgr));
+    cinfo->dest = (struct jpeg_destination_mgr *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+				  SIZEOF(my_mem_destination_mgr));
  }

  dest = (my_mem_dest_ptr) cinfo->dest;
@@ -2,7 +2,7 @@
 * jdatasrc.c
 *
 * Copyright (C) 1994-1996, Thomas G. Lane.
- * Modified 2009-2019 by Guido Vollbeding.
+ * Modified 2009-2015 by Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
@@ -156,23 +156,21 @@ METHODDEF(void)
 skip_input_data (j_decompress_ptr cinfo, long num_bytes)
 {
  struct jpeg_source_mgr * src = cinfo->src;
-  size_t nbytes;

  /* Just a dumb implementation for now.  Could use fseek() except
   * it doesn't work on pipes.  Not clear that being smart is worth
   * any trouble anyway --- large skips are infrequent.
   */
  if (num_bytes > 0) {
-    nbytes = (size_t) num_bytes;
-    while (nbytes > src->bytes_in_buffer) {
-      nbytes -= src->bytes_in_buffer;
+    while (num_bytes > (long) src->bytes_in_buffer) {
+      num_bytes -= (long) src->bytes_in_buffer;
      (void) (*src->fill_input_buffer) (cinfo);
      /* note we assume that fill_input_buffer will never return FALSE,
       * so suspension need not be handled.
       */
    }
-    src->next_input_byte += nbytes;
-    src->bytes_in_buffer -= nbytes;
+    src->next_input_byte += (size_t) num_bytes;
+    src->bytes_in_buffer -= (size_t) num_bytes;
  }
 }

@@ -221,11 +219,13 @@ jpeg_stdio_src (j_decompress_ptr cinfo, FILE * infile)
   * manager serially with the same JPEG object.  Caveat programmer.
   */
  if (cinfo->src == NULL) {	/* first time for this JPEG object? */
-    cinfo->src = (struct jpeg_source_mgr *) (*cinfo->mem->alloc_small)
-      ((j_common_ptr) cinfo, JPOOL_PERMANENT, SIZEOF(my_source_mgr));
+    cinfo->src = (struct jpeg_source_mgr *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+				  SIZEOF(my_source_mgr));
    src = (my_src_ptr) cinfo->src;
-    src->buffer = (JOCTET *) (*cinfo->mem->alloc_small)
-      ((j_common_ptr) cinfo, JPOOL_PERMANENT, INPUT_BUF_SIZE * SIZEOF(JOCTET));
+    src->buffer = (JOCTET *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+				  INPUT_BUF_SIZE * SIZEOF(JOCTET));
  }

  src = (my_src_ptr) cinfo->src;
@@ -247,7 +247,7 @@ jpeg_stdio_src (j_decompress_ptr cinfo, FILE * infile)

 GLOBAL(void)
 jpeg_mem_src (j_decompress_ptr cinfo,
-	      const unsigned char * inbuffer, size_t insize)
+	      const unsigned char * inbuffer, unsigned long insize)
 {
  struct jpeg_source_mgr * src;

@@ -259,8 +259,9 @@ jpeg_mem_src (j_decompress_ptr cinfo,
   * the first one.
   */
  if (cinfo->src == NULL) {	/* first time for this JPEG object? */
-    cinfo->src = (struct jpeg_source_mgr *) (*cinfo->mem->alloc_small)
-      ((j_common_ptr) cinfo, JPOOL_PERMANENT, SIZEOF(struct jpeg_source_mgr));
+    cinfo->src = (struct jpeg_source_mgr *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+				  SIZEOF(struct jpeg_source_mgr));
  }

  src = cinfo->src;
@@ -269,6 +270,6 @@ jpeg_mem_src (j_decompress_ptr cinfo,
  src->skip_input_data = skip_input_data;
  src->resync_to_restart = jpeg_resync_to_restart; /* use default method */
  src->term_source = term_source;
-  src->bytes_in_buffer = insize;
+  src->bytes_in_buffer = (size_t) insize;
  src->next_input_byte = (const JOCTET *) inbuffer;
 }
@@ -2,7 +2,7 @@
 * jdcolor.c
 *
 * Copyright (C) 1991-1997, Thomas G. Lane.
- * Modified 2011-2019 by Guido Vollbeding.
+ * Modified 2011-2017 by Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
@@ -124,22 +124,28 @@ build_ycc_rgb_table (j_decompress_ptr cinfo)
  INT32 x;
  SHIFT_TEMPS

-  cconvert->Cr_r_tab = (int *) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(int));
-  cconvert->Cb_b_tab = (int *) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(int));
-  cconvert->Cr_g_tab = (INT32 *) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(INT32));
-  cconvert->Cb_g_tab = (INT32 *) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(INT32));
+  cconvert->Cr_r_tab = (int *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(int));
+  cconvert->Cb_b_tab = (int *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(int));
+  cconvert->Cr_g_tab = (INT32 *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(INT32));
+  cconvert->Cb_g_tab = (INT32 *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(INT32));

  for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
    /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
    /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
    /* Cr=>R value is nearest int to 1.402 * x */
-    cconvert->Cr_r_tab[i] = (int) DESCALE(FIX(1.402) * x, SCALEBITS);
+    cconvert->Cr_r_tab[i] = (int)
+		    RIGHT_SHIFT(FIX(1.402) * x + ONE_HALF, SCALEBITS);
    /* Cb=>B value is nearest int to 1.772 * x */
-    cconvert->Cb_b_tab[i] = (int) DESCALE(FIX(1.772) * x, SCALEBITS);
+    cconvert->Cb_b_tab[i] = (int)
+		    RIGHT_SHIFT(FIX(1.772) * x + ONE_HALF, SCALEBITS);
    /* Cr=>G value is scaled-up -0.714136286 * x */
    cconvert->Cr_g_tab[i] = (- FIX(0.714136286)) * x;
    /* Cb=>G value is scaled-up -0.344136286 * x */
@@ -158,22 +164,28 @@ build_bg_ycc_rgb_table (j_decompress_ptr cinfo)
  INT32 x;
  SHIFT_TEMPS

-  cconvert->Cr_r_tab = (int *) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(int));
-  cconvert->Cb_b_tab = (int *) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(int));
-  cconvert->Cr_g_tab = (INT32 *) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(INT32));
-  cconvert->Cb_g_tab = (INT32 *) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(INT32));
+  cconvert->Cr_r_tab = (int *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(int));
+  cconvert->Cb_b_tab = (int *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(int));
+  cconvert->Cr_g_tab = (INT32 *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(INT32));
+  cconvert->Cb_g_tab = (INT32 *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(INT32));

  for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
    /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
    /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
    /* Cr=>R value is nearest int to 2.804 * x */
-    cconvert->Cr_r_tab[i] = (int) DESCALE(FIX(2.804) * x, SCALEBITS);
+    cconvert->Cr_r_tab[i] = (int)
+		    RIGHT_SHIFT(FIX(2.804) * x + ONE_HALF, SCALEBITS);
    /* Cb=>B value is nearest int to 3.544 * x */
-    cconvert->Cb_b_tab[i] = (int) DESCALE(FIX(3.544) * x, SCALEBITS);
+    cconvert->Cb_b_tab[i] = (int)
+		    RIGHT_SHIFT(FIX(3.544) * x + ONE_HALF, SCALEBITS);
    /* Cr=>G value is scaled-up -1.428272572 * x */
    cconvert->Cr_g_tab[i] = (- FIX(1.428272572)) * x;
    /* Cb=>G value is scaled-up -0.688272572 * x */
@@ -189,7 +201,6 @@ build_bg_ycc_rgb_table (j_decompress_ptr cinfo)
 * Note that we change from noninterleaved, one-plane-per-component format
 * to interleaved-pixel format.  The output buffer is therefore three times
 * as wide as the input buffer.
- *
 * A starting row offset is provided only for the input buffer.  The caller
 * can easily adjust the passed output_buf value to accommodate any row
 * offset required on that side.
@@ -253,8 +264,9 @@ build_rgb_y_table (j_decompress_ptr cinfo)
  INT32 i;

  /* Allocate and fill in the conversion tables. */
-  cconvert->rgb_y_tab = rgb_y_tab = (INT32 *) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, TABLE_SIZE * SIZEOF(INT32));
+  cconvert->rgb_y_tab = rgb_y_tab = (INT32 *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(TABLE_SIZE * SIZEOF(INT32)));

  for (i = 0; i <= MAXJSAMPLE; i++) {
    rgb_y_tab[i+R_Y_OFF] = FIX(0.299) * i;
@@ -274,8 +286,8 @@ rgb_gray_convert (j_decompress_ptr cinfo,
 		  JSAMPARRAY output_buf, int num_rows)
 {
  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
-  register int r, g, b;
  register INT32 * ctab = cconvert->rgb_y_tab;
+  register int r, g, b;
  register JSAMPROW outptr;
  register JSAMPROW inptr0, inptr1, inptr2;
  register JDIMENSION col;
@@ -301,7 +313,6 @@ rgb_gray_convert (j_decompress_ptr cinfo,


 /*
- * Convert some rows of samples to the output colorspace.
 * [R-G,G,B-G] to [R,G,B] conversion with modulo calculation
 * (inverse color transform).
 * This can be seen as an adaption of the general YCbCr->RGB
@@ -353,8 +364,8 @@ rgb1_gray_convert (j_decompress_ptr cinfo,
 		   JSAMPARRAY output_buf, int num_rows)
 {
  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
-  register int r, g, b;
  register INT32 * ctab = cconvert->rgb_y_tab;
+  register int r, g, b;
  register JSAMPROW outptr;
  register JSAMPROW inptr0, inptr1, inptr2;
  register JDIMENSION col;
@@ -385,7 +396,6 @@ rgb1_gray_convert (j_decompress_ptr cinfo,


 /*
- * Convert some rows of samples to the output colorspace.
 * No colorspace change, but conversion from separate-planes
 * to interleaved representation.
 */
@@ -420,7 +430,6 @@ rgb_convert (j_decompress_ptr cinfo,
 /*
 * Color conversion for no colorspace change: just copy the data,
 * converting from separate-planes to interleaved representation.
- * We assume out_color_components == num_components.
 */

 METHODDEF(void)
@@ -428,21 +437,20 @@ null_convert (j_decompress_ptr cinfo,
 	      JSAMPIMAGE input_buf, JDIMENSION input_row,
 	      JSAMPARRAY output_buf, int num_rows)
 {
+  int ci;
+  register int nc = cinfo->num_components;
  register JSAMPROW outptr;
  register JSAMPROW inptr;
-  register JDIMENSION count;
-  register int num_comps = cinfo->num_components;
+  register JDIMENSION col;
  JDIMENSION num_cols = cinfo->output_width;
-  int ci;

  while (--num_rows >= 0) {
-    /* It seems fastest to make a separate pass for each component. */
-    for (ci = 0; ci < num_comps; ci++) {
+    for (ci = 0; ci < nc; ci++) {
      inptr = input_buf[ci][input_row];
      outptr = output_buf[0] + ci;
-      for (count = num_cols; count > 0; count--) {
-	*outptr = *inptr++;	/* don't need GETJSAMPLE() here */
-	outptr += num_comps;
+      for (col = 0; col < num_cols; col++) {
+	*outptr = *inptr++;	/* needn't bother with GETJSAMPLE() here */
+	outptr += nc;
      }
    }
    input_row++;
@@ -496,10 +504,9 @@ gray_rgb_convert (j_decompress_ptr cinfo,


 /*
- * Convert some rows of samples to the output colorspace.
- * This version handles Adobe-style YCCK->CMYK conversion,
- * where we convert YCbCr to R=1-C, G=1-M, and B=1-Y using the
- * same conversion as above, while passing K (black) unchanged.
+ * Adobe-style YCCK->CMYK conversion.
+ * We convert YCbCr to R=1-C, G=1-M, and B=1-Y using the same
+ * conversion as above, while passing K (black) unchanged.
 * We assume build_ycc_rgb_table has been called.
 */

@@ -570,8 +577,9 @@ jinit_color_deconverter (j_decompress_ptr cinfo)
  my_cconvert_ptr cconvert;
  int ci;

-  cconvert = (my_cconvert_ptr) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_color_deconverter));
+  cconvert = (my_cconvert_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_color_deconverter));
  cinfo->cconvert = &cconvert->pub;
  cconvert->pub.start_pass = start_pass_dcolor;

@@ -599,6 +607,7 @@ jinit_color_deconverter (j_decompress_ptr cinfo)
  default:			/* JCS_UNKNOWN can be anything */
    if (cinfo->num_components < 1)
      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    break;
  }

  /* Support color transform only for RGB colorspaces */
@@ -675,18 +684,19 @@ jinit_color_deconverter (j_decompress_ptr cinfo)

  case JCS_BG_RGB:
    cinfo->out_color_components = RGB_PIXELSIZE;
-    if (cinfo->jpeg_color_space != JCS_BG_RGB)
+    if (cinfo->jpeg_color_space == JCS_BG_RGB) {
+      switch (cinfo->color_transform) {
+      case JCT_NONE:
+	cconvert->pub.color_convert = rgb_convert;
+	break;
+      case JCT_SUBTRACT_GREEN:
+	cconvert->pub.color_convert = rgb1_rgb_convert;
+	break;
+      default:
+	ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+      }
+    } else
      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    switch (cinfo->color_transform) {
-    case JCT_NONE:
-      cconvert->pub.color_convert = rgb_convert;
-      break;
-    case JCT_SUBTRACT_GREEN:
-      cconvert->pub.color_convert = rgb1_rgb_convert;
-      break;
-    default:
-      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    }
    break;

  case JCS_CMYK:
@@ -704,12 +714,14 @@ jinit_color_deconverter (j_decompress_ptr cinfo)
    }
    break;

-  default:		/* permit null conversion to same output space */
-    if (cinfo->out_color_space != cinfo->jpeg_color_space)
-      /* unsupported non-null conversion */
+  default:
+    /* Permit null conversion to same output space */
+    if (cinfo->out_color_space == cinfo->jpeg_color_space) {
+      cinfo->out_color_components = cinfo->num_components;
+      cconvert->pub.color_convert = null_convert;
+    } else			/* unsupported non-null conversion */
      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    cinfo->out_color_components = cinfo->num_components;
-    cconvert->pub.color_convert = null_convert;
+    break;
  }

  if (cinfo->quantize_colors)
@@ -2,7 +2,7 @@
 * jdct.h
 *
 * Copyright (C) 1994-1996, Thomas G. Lane.
- * Modified 2002-2019 by Guido Vollbeding.
+ * Modified 2002-2017 by Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
@@ -358,6 +358,13 @@ EXTERN(void) jpeg_idct_1x2

 #define FIX(x)	((INT32) ((x) * CONST_SCALE + 0.5))

+/* Descale and correctly round an INT32 value that's scaled by N bits.
+ * We assume RIGHT_SHIFT rounds towards minus infinity, so adding
+ * the fudge factor is correct for either sign of X.
+ */
+
+#define DESCALE(x,n)  RIGHT_SHIFT((x) + (ONE << ((n)-1)), n)
+
 /* Multiply an INT32 variable by an INT32 constant to yield an INT32 result.
 * This macro is used only when the two inputs will actually be no more than
 * 16 bits wide, so that a 16x16->32 bit multiply can be used instead of a
@@ -2,7 +2,7 @@
 * jdhuff.c
 *
 * Copyright (C) 1991-1997, Thomas G. Lane.
- * Modified 2006-2019 by Guido Vollbeding.
+ * Modified 2006-2016 by Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
@@ -341,12 +341,13 @@ jpeg_make_d_derived_tbl (j_decompress_ptr cinfo, boolean isDC, int tblno,
  htbl =
    isDC ? cinfo->dc_huff_tbl_ptrs[tblno] : cinfo->ac_huff_tbl_ptrs[tblno];
  if (htbl == NULL)
-    htbl = jpeg_std_huff_table((j_common_ptr) cinfo, isDC, tblno);
+    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);

  /* Allocate a workspace if we haven't already done so. */
  if (*pdtbl == NULL)
-    *pdtbl = (d_derived_tbl *) (*cinfo->mem->alloc_small)
-      ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(d_derived_tbl));
+    *pdtbl = (d_derived_tbl *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  SIZEOF(d_derived_tbl));
  dtbl = *pdtbl;
  dtbl->pub = htbl;		/* fill in back link */
  
@@ -705,7 +706,7 @@ process_restart (j_decompress_ptr cinfo)

 METHODDEF(boolean)
 decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
-{
+{   
  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
  int Al = cinfo->Al;
  register int s, r;
@@ -729,7 +730,7 @@ decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
  if (! entropy->insufficient_data) {

    /* Load up working state */
-    BITREAD_LOAD_STATE(cinfo, entropy->bitstate);
+    BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
    ASSIGN_STATE(state, entropy->saved);

    /* Outer loop handles each block in the MCU */
@@ -758,13 +759,12 @@ decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
    }

    /* Completed MCU, so update state */
-    BITREAD_SAVE_STATE(cinfo, entropy->bitstate);
+    BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
    ASSIGN_STATE(entropy->saved, state);
  }

-  /* Account for restart interval if using restarts */
-  if (cinfo->restart_interval)
-    entropy->restarts_to_go--;
+  /* Account for restart interval (no-op if not using restarts) */
+  entropy->restarts_to_go--;

  return TRUE;
 }
@@ -777,7 +777,7 @@ decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)

 METHODDEF(boolean)
 decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
-{
+{   
  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
  register int s, k, r;
  unsigned int EOBRUN;
@@ -809,7 +809,7 @@ decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
    if (EOBRUN)			/* if it's a band of zeroes... */
      EOBRUN--;			/* ...process it now (we do nothing) */
    else {
-      BITREAD_LOAD_STATE(cinfo, entropy->bitstate);
+      BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
      Se = cinfo->Se;
      Al = cinfo->Al;
      natural_order = cinfo->natural_order;
@@ -842,16 +842,15 @@ decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 	}
      }

-      BITREAD_SAVE_STATE(cinfo, entropy->bitstate);
+      BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
    }

    /* Completed MCU, so update state */
    entropy->saved.EOBRUN = EOBRUN;	/* only part of saved state we need */
  }

-  /* Account for restart interval if using restarts */
-  if (cinfo->restart_interval)
-    entropy->restarts_to_go--;
+  /* Account for restart interval (no-op if not using restarts) */
+  entropy->restarts_to_go--;

  return TRUE;
 }
@@ -865,10 +864,9 @@ decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)

 METHODDEF(boolean)
 decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
-{
+{   
  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
-  JCOEF p1;
-  int blkn;
+  int p1, blkn;
  BITREAD_STATE_VARS;

  /* Process restart marker if needed; may have to suspend */
@@ -883,7 +881,7 @@ decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
   */

  /* Load up working state */
-  BITREAD_LOAD_STATE(cinfo, entropy->bitstate);
+  BITREAD_LOAD_STATE(cinfo,entropy->bitstate);

  p1 = 1 << cinfo->Al;		/* 1 in the bit position being coded */

@@ -898,11 +896,10 @@ decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
  }

  /* Completed MCU, so update state */
-  BITREAD_SAVE_STATE(cinfo, entropy->bitstate);
+  BITREAD_SAVE_STATE(cinfo,entropy->bitstate);

-  /* Account for restart interval if using restarts */
-  if (cinfo->restart_interval)
-    entropy->restarts_to_go--;
+  /* Account for restart interval (no-op if not using restarts) */
+  entropy->restarts_to_go--;

  return TRUE;
 }
@@ -914,12 +911,11 @@ decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)

 METHODDEF(boolean)
 decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
-{
+{   
  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
  register int s, k, r;
  unsigned int EOBRUN;
-  int Se;
-  JCOEF p1, m1;
+  int Se, p1, m1;
  const int * natural_order;
  JBLOCKROW block;
  JCOEFPTR thiscoef;
@@ -941,11 +937,11 @@ decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)

    Se = cinfo->Se;
    p1 = 1 << cinfo->Al;	/* 1 in the bit position being coded */
-    m1 = -p1;			/* -1 in the bit position being coded */
+    m1 = (-1) << cinfo->Al;	/* -1 in the bit position being coded */
    natural_order = cinfo->natural_order;

    /* Load up working state */
-    BITREAD_LOAD_STATE(cinfo, entropy->bitstate);
+    BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
    EOBRUN = entropy->saved.EOBRUN; /* only part of saved state we need */

    /* There is always only one block per MCU */
@@ -1047,13 +1043,12 @@ decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
    }

    /* Completed MCU, so update state */
-    BITREAD_SAVE_STATE(cinfo, entropy->bitstate);
+    BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
    entropy->saved.EOBRUN = EOBRUN; /* only part of saved state we need */
  }

-  /* Account for restart interval if using restarts */
-  if (cinfo->restart_interval)
-    entropy->restarts_to_go--;
+  /* Account for restart interval (no-op if not using restarts) */
+  entropy->restarts_to_go--;

  return TRUE;

@@ -1096,7 +1091,7 @@ decode_mcu_sub (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
    Se = cinfo->lim_Se;

    /* Load up working state */
-    BITREAD_LOAD_STATE(cinfo, entropy->bitstate);
+    BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
    ASSIGN_STATE(state, entropy->saved);

    /* Outer loop handles each block in the MCU */
@@ -1183,13 +1178,12 @@ decode_mcu_sub (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
    }

    /* Completed MCU, so update state */
-    BITREAD_SAVE_STATE(cinfo, entropy->bitstate);
+    BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
    ASSIGN_STATE(entropy->saved, state);
  }

-  /* Account for restart interval if using restarts */
-  if (cinfo->restart_interval)
-    entropy->restarts_to_go--;
+  /* Account for restart interval (no-op if not using restarts) */
+  entropy->restarts_to_go--;

  return TRUE;
 }
@@ -1221,7 +1215,7 @@ decode_mcu (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
  if (! entropy->insufficient_data) {

    /* Load up working state */
-    BITREAD_LOAD_STATE(cinfo, entropy->bitstate);
+    BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
    ASSIGN_STATE(state, entropy->saved);

    /* Outer loop handles each block in the MCU */
@@ -1308,13 +1302,12 @@ decode_mcu (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
    }

    /* Completed MCU, so update state */
-    BITREAD_SAVE_STATE(cinfo, entropy->bitstate);
+    BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
    ASSIGN_STATE(entropy->saved, state);
  }

-  /* Account for restart interval if using restarts */
-  if (cinfo->restart_interval)
-    entropy->restarts_to_go--;
+  /* Account for restart interval (no-op if not using restarts) */
+  entropy->restarts_to_go--;

  return TRUE;
 }
@@ -1350,11 +1343,11 @@ start_pass_huff_decoder (j_decompress_ptr cinfo)
 	goto bad;
    }
    if (cinfo->Al > 13) {	/* need not check for < 0 */
-      /* Arguably the maximum Al value should be less than 13 for 8-bit
-       * precision, but the spec doesn't say so, and we try to be liberal
-       * about what we accept.  Note: large Al values could result in
-       * out-of-range DC coefficients during early scans, leading to bizarre
-       * displays due to overflows in the IDCT math.  But we won't crash.
+      /* Arguably the maximum Al value should be less than 13 for 8-bit precision,
+       * but the spec doesn't say so, and we try to be liberal about what we
+       * accept.  Note: large Al values could result in out-of-range DC
+       * coefficients during early scans, leading to bizarre displays due to
+       * overflows in the IDCT math.  But we won't crash.
       */
      bad:
      ERREXIT4(cinfo, JERR_BAD_PROGRESSION,
@@ -1458,8 +1451,7 @@ start_pass_huff_decoder (j_decompress_ptr cinfo)
      compptr = cinfo->cur_comp_info[ci];
      /* Precalculate which table to use for each block */
      entropy->dc_cur_tbls[blkn] = entropy->dc_derived_tbls[compptr->dc_tbl_no];
-      entropy->ac_cur_tbls[blkn] =	/* AC needs no table when not present */
-	cinfo->lim_Se ? entropy->ac_derived_tbls[compptr->ac_tbl_no] : NULL;
+      entropy->ac_cur_tbls[blkn] = entropy->ac_derived_tbls[compptr->ac_tbl_no];
      /* Decide whether we really care about the coefficient values */
      if (compptr->component_needed) {
 	ci = compptr->DCT_v_scaled_size;
@@ -1502,6 +1494,7 @@ start_pass_huff_decoder (j_decompress_ptr cinfo)
 	  if (ci <= 0 || ci > 8) ci = 8;
 	  if (i <= 0 || i > 8) i = 8;
 	  entropy->coef_limit[blkn] = 1 + jpeg_zigzag_order[ci - 1][i - 1];
+	  break;
 	}
      } else {
 	entropy->coef_limit[blkn] = 0;
@@ -1529,8 +1522,9 @@ jinit_huff_decoder (j_decompress_ptr cinfo)
  huff_entropy_ptr entropy;
  int i;

-  entropy = (huff_entropy_ptr) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(huff_entropy_decoder));
+  entropy = (huff_entropy_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(huff_entropy_decoder));
  cinfo->entropy = &entropy->pub;
  entropy->pub.start_pass = start_pass_huff_decoder;
  entropy->pub.finish_pass = finish_pass_huff;
@@ -1538,9 +1532,9 @@ jinit_huff_decoder (j_decompress_ptr cinfo)
  if (cinfo->progressive_mode) {
    /* Create progression status table */
    int *coef_bit_ptr, ci;
-    cinfo->coef_bits = (int (*)[DCTSIZE2]) (*cinfo->mem->alloc_small)
-      ((j_common_ptr) cinfo, JPOOL_IMAGE,
-       cinfo->num_components * DCTSIZE2 * SIZEOF(int));
+    cinfo->coef_bits = (int (*)[DCTSIZE2])
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  cinfo->num_components*DCTSIZE2*SIZEOF(int));
    coef_bit_ptr = & cinfo->coef_bits[0][0];
    for (ci = 0; ci < cinfo->num_components; ci++)
      for (i = 0; i < DCTSIZE2; i++)
@@ -1551,7 +1545,7 @@ jinit_huff_decoder (j_decompress_ptr cinfo)
      entropy->derived_tbls[i] = NULL;
    }
  } else {
-    /* Mark derived tables unallocated */
+    /* Mark tables unallocated */
    for (i = 0; i < NUM_HUFF_TBLS; i++) {
      entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;
    }
@@ -2,7 +2,7 @@
 * jdmarker.c
 *
 * Copyright (C) 1991-1998, Thomas G. Lane.
- * Modified 2009-2019 by Guido Vollbeding.
+ * Modified 2009-2013 by Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
@@ -496,6 +496,8 @@ get_dht (j_decompress_ptr cinfo)
    if (count > 256 || ((INT32) count) > length)
      ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);

+    MEMZERO(huffval, SIZEOF(huffval)); /* pre-zero array for later copy */
+
    for (i = 0; i < count; i++)
      INPUT_BYTE(cinfo, huffval[i], return FALSE);

@@ -515,8 +517,7 @@ get_dht (j_decompress_ptr cinfo)
      *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
  
    MEMCOPY((*htblptr)->bits, bits, SIZEOF((*htblptr)->bits));
-    if (count > 0)
-      MEMCOPY((*htblptr)->huffval, huffval, count * SIZEOF(UINT8));
+    MEMCOPY((*htblptr)->huffval, huffval, SIZEOF((*htblptr)->huffval));
  }

  if (length != 0)
@@ -576,14 +577,14 @@ get_dqt (j_decompress_ptr cinfo)
 	count = DCTSIZE2;
    }

-    switch ((int) count) {
+    switch (count) {
    case (2*2): natural_order = jpeg_natural_order2; break;
    case (3*3): natural_order = jpeg_natural_order3; break;
    case (4*4): natural_order = jpeg_natural_order4; break;
    case (5*5): natural_order = jpeg_natural_order5; break;
    case (6*6): natural_order = jpeg_natural_order6; break;
    case (7*7): natural_order = jpeg_natural_order7; break;
-    default:    natural_order = jpeg_natural_order;
+    default:    natural_order = jpeg_natural_order;  break;
    }

    for (i = 0; i < count; i++) {
@@ -783,6 +784,7 @@ examine_app0 (j_decompress_ptr cinfo, JOCTET FAR * data,
    default:
      TRACEMS2(cinfo, 1, JTRC_JFIF_EXTENSION,
 	       GETJOCTET(data[5]), (int) totallen);
+      break;
    }
  } else {
    /* Start of APP0 does not match "JFIF" or "JFXX", or too short */
@@ -856,6 +858,7 @@ get_interesting_appn (j_decompress_ptr cinfo)
  default:
    /* can't get here unless jpeg_save_markers chooses wrong processor */
    ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, cinfo->unread_marker);
+    break;
  }

  /* skip any remaining data -- could be lots */
@@ -961,6 +964,7 @@ save_marker (j_decompress_ptr cinfo)
  default:
    TRACEMS2(cinfo, 1, JTRC_MISC_MARKER, cinfo->unread_marker,
 	     (int) (data_length + length));
+    break;
  }

  /* skip any remaining data -- could be lots */
@@ -1236,6 +1240,7 @@ read_markers (j_decompress_ptr cinfo)
       * ought to change!
       */
      ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, cinfo->unread_marker);
+      break;
    }
    /* Successfully processed marker, so reset state variable */
    cinfo->unread_marker = 0;
@@ -1411,8 +1416,9 @@ jinit_marker_reader (j_decompress_ptr cinfo)
  int i;

  /* Create subobject in permanent pool */
-  marker = (my_marker_ptr) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_PERMANENT, SIZEOF(my_marker_reader));
+  marker = (my_marker_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+				SIZEOF(my_marker_reader));
  cinfo->marker = &marker->pub;
  /* Initialize public method pointers */
  marker->pub.reset_marker_reader = reset_marker_reader;
@@ -2,7 +2,7 @@
 * jdmaster.c
 *
 * Copyright (C) 1991-1997, Thomas G. Lane.
- * Modified 2002-2019 by Guido Vollbeding.
+ * Modified 2002-2017 by Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
@@ -104,7 +104,7 @@ jpeg_calc_output_dimensions (j_decompress_ptr cinfo)
 */
 {
 #ifdef IDCT_SCALING_SUPPORTED
-  int ci, ssize;
+  int ci;
  jpeg_component_info *compptr;
 #endif

@@ -124,23 +124,19 @@ jpeg_calc_output_dimensions (j_decompress_ptr cinfo)
   */
  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
       ci++, compptr++) {
-    ssize = 1;
-    if (! cinfo->raw_data_out)
-      while (cinfo->min_DCT_h_scaled_size * ssize <=
-	     (cinfo->do_fancy_upsampling ? DCTSIZE : DCTSIZE / 2) &&
-	     (cinfo->max_h_samp_factor % (compptr->h_samp_factor * ssize * 2)) ==
-	     0) {
-	ssize = ssize * 2;
-      }
+    int ssize = 1;
+    while (cinfo->min_DCT_h_scaled_size * ssize <=
+	   (cinfo->do_fancy_upsampling ? DCTSIZE : DCTSIZE / 2) &&
+	   (cinfo->max_h_samp_factor % (compptr->h_samp_factor * ssize * 2)) == 0) {
+      ssize = ssize * 2;
+    }
    compptr->DCT_h_scaled_size = cinfo->min_DCT_h_scaled_size * ssize;
    ssize = 1;
-    if (! cinfo->raw_data_out)
-      while (cinfo->min_DCT_v_scaled_size * ssize <=
-	     (cinfo->do_fancy_upsampling ? DCTSIZE : DCTSIZE / 2) &&
-	     (cinfo->max_v_samp_factor % (compptr->v_samp_factor * ssize * 2)) ==
-	     0) {
-	ssize = ssize * 2;
-      }
+    while (cinfo->min_DCT_v_scaled_size * ssize <=
+	   (cinfo->do_fancy_upsampling ? DCTSIZE : DCTSIZE / 2) &&
+	   (cinfo->max_v_samp_factor % (compptr->v_samp_factor * ssize * 2)) == 0) {
+      ssize = ssize * 2;
+    }
    compptr->DCT_v_scaled_size = cinfo->min_DCT_v_scaled_size * ssize;

    /* We don't support IDCT ratios larger than 2. */
@@ -148,10 +144,13 @@ jpeg_calc_output_dimensions (j_decompress_ptr cinfo)
 	compptr->DCT_h_scaled_size = compptr->DCT_v_scaled_size * 2;
    else if (compptr->DCT_v_scaled_size > compptr->DCT_h_scaled_size * 2)
 	compptr->DCT_v_scaled_size = compptr->DCT_h_scaled_size * 2;
+  }

-    /* Recompute downsampled dimensions of components;
-     * application needs to know these if using raw downsampled data.
-     */
+  /* Recompute downsampled dimensions of components;
+   * application needs to know these if using raw downsampled data.
+   */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
    /* Size in samples, after IDCT scaling */
    compptr->downsampled_width = (JDIMENSION)
      jdiv_round_up((long) cinfo->image_width *
@@ -173,10 +172,8 @@ jpeg_calc_output_dimensions (j_decompress_ptr cinfo)
    break;
  case JCS_RGB:
  case JCS_BG_RGB:
-#if RGB_PIXELSIZE != 3
    cinfo->out_color_components = RGB_PIXELSIZE;
    break;
-#endif /* else share code with YCbCr */
  case JCS_YCbCr:
  case JCS_BG_YCC:
    cinfo->out_color_components = 3;
@@ -187,6 +184,7 @@ jpeg_calc_output_dimensions (j_decompress_ptr cinfo)
    break;
  default:			/* else must be same colorspace as in file */
    cinfo->out_color_components = cinfo->num_components;
+    break;
  }
  cinfo->output_components = (cinfo->quantize_colors ? 1 :
 			      cinfo->out_color_components);
@@ -527,8 +525,9 @@ jinit_master_decompress (j_decompress_ptr cinfo)
 {
  my_master_ptr master;

-  master = (my_master_ptr) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_decomp_master));
+  master = (my_master_ptr)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  SIZEOF(my_decomp_master));
  cinfo->master = &master->pub;
  master->pub.prepare_for_output_pass = prepare_for_output_pass;
  master->pub.finish_output_pass = finish_output_pass;
@@ -2,7 +2,7 @@
 * jdmerge.c
 *
 * Copyright (C) 1994-1996, Thomas G. Lane.
- * Modified 2013-2019 by Guido Vollbeding.
+ * Modified 2013-2017 by Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
@@ -95,22 +95,28 @@ build_ycc_rgb_table (j_decompress_ptr cinfo)
  INT32 x;
  SHIFT_TEMPS

-  upsample->Cr_r_tab = (int *) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(int));
-  upsample->Cb_b_tab = (int *) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(int));
-  upsample->Cr_g_tab = (INT32 *) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(INT32));
-  upsample->Cb_g_tab = (INT32 *) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(INT32));
+  upsample->Cr_r_tab = (int *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(int));
+  upsample->Cb_b_tab = (int *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(int));
+  upsample->Cr_g_tab = (INT32 *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(INT32));
+  upsample->Cb_g_tab = (INT32 *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(INT32));

  for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
    /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
    /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
    /* Cr=>R value is nearest int to 1.402 * x */
-    upsample->Cr_r_tab[i] = (int) DESCALE(FIX(1.402) * x, SCALEBITS);
+    upsample->Cr_r_tab[i] = (int)
+		    RIGHT_SHIFT(FIX(1.402) * x + ONE_HALF, SCALEBITS);
    /* Cb=>B value is nearest int to 1.772 * x */
-    upsample->Cb_b_tab[i] = (int) DESCALE(FIX(1.772) * x, SCALEBITS);
+    upsample->Cb_b_tab[i] = (int)
+		    RIGHT_SHIFT(FIX(1.772) * x + ONE_HALF, SCALEBITS);
    /* Cr=>G value is scaled-up -0.714136286 * x */
    upsample->Cr_g_tab[i] = (- FIX(0.714136286)) * x;
    /* Cb=>G value is scaled-up -0.344136286 * x */
@@ -129,22 +135,28 @@ build_bg_ycc_rgb_table (j_decompress_ptr cinfo)
  INT32 x;
  SHIFT_TEMPS

-  upsample->Cr_r_tab = (int *) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(int));
-  upsample->Cb_b_tab = (int *) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(int));
-  upsample->Cr_g_tab = (INT32 *) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(INT32));
-  upsample->Cb_g_tab = (INT32 *) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(INT32));
+  upsample->Cr_r_tab = (int *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(int));
+  upsample->Cb_b_tab = (int *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(int));
+  upsample->Cr_g_tab = (INT32 *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(INT32));
+  upsample->Cb_g_tab = (INT32 *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(INT32));

  for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
    /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
    /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
    /* Cr=>R value is nearest int to 2.804 * x */
-    upsample->Cr_r_tab[i] = (int) DESCALE(FIX(2.804) * x, SCALEBITS);
+    upsample->Cr_r_tab[i] = (int)
+		    RIGHT_SHIFT(FIX(2.804) * x + ONE_HALF, SCALEBITS);
    /* Cb=>B value is nearest int to 3.544 * x */
-    upsample->Cb_b_tab[i] = (int) DESCALE(FIX(3.544) * x, SCALEBITS);
+    upsample->Cb_b_tab[i] = (int)
+		    RIGHT_SHIFT(FIX(3.544) * x + ONE_HALF, SCALEBITS);
    /* Cr=>G value is scaled-up -1.428272572 * x */
    upsample->Cr_g_tab[i] = (- FIX(1.428272572)) * x;
    /* Cb=>G value is scaled-up -0.688272572 * x */
@@ -407,8 +419,9 @@ jinit_merged_upsampler (j_decompress_ptr cinfo)
 {
  my_upsample_ptr upsample;

-  upsample = (my_upsample_ptr) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_upsampler));
+  upsample = (my_upsample_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_upsampler));
  cinfo->upsample = &upsample->pub;
  upsample->pub.start_pass = start_pass_merged_upsample;
  upsample->pub.need_context_rows = FALSE;
@@ -419,9 +432,9 @@ jinit_merged_upsampler (j_decompress_ptr cinfo)
    upsample->pub.upsample = merged_2v_upsample;
    upsample->upmethod = h2v2_merged_upsample;
    /* Allocate a spare row buffer */
-    upsample->spare_row = (JSAMPROW) (*cinfo->mem->alloc_large)
-      ((j_common_ptr) cinfo, JPOOL_IMAGE,
-       (size_t) upsample->out_row_width * SIZEOF(JSAMPLE));
+    upsample->spare_row = (JSAMPROW)
+      (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+		(size_t) (upsample->out_row_width * SIZEOF(JSAMPLE)));
  } else {
    upsample->pub.upsample = merged_1v_upsample;
    upsample->upmethod = h2v1_merged_upsample;
@@ -2,7 +2,7 @@
 * jerror.h
 *
 * Copyright (C) 1994-1997, Thomas G. Lane.
- * Modified 1997-2018 by Guido Vollbeding.
+ * Modified 1997-2012 by Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
@@ -84,7 +84,7 @@ JMESSAGE(JERR_EOI_EXPECTED, "Didn't expect more than one scan")
 JMESSAGE(JERR_FILE_READ, "Input file read error")
 JMESSAGE(JERR_FILE_WRITE, "Output file write error --- out of disk space?")
 JMESSAGE(JERR_FRACT_SAMPLE_NOTIMPL, "Fractional sampling not implemented yet")
-JMESSAGE(JERR_HUFF_CLEN_OUTOFBOUNDS, "Huffman code size table out of bounds")
+JMESSAGE(JERR_HUFF_CLEN_OVERFLOW, "Huffman code size table overflow")
 JMESSAGE(JERR_HUFF_MISSING_CODE, "Missing Huffman code table entry")
 JMESSAGE(JERR_IMAGE_TOO_BIG, "Maximum supported image dimension is %u pixels")
 JMESSAGE(JERR_INPUT_EMPTY, "Empty input file")
@@ -2,7 +2,7 @@
 * jfdctint.c
 *
 * Copyright (C) 1991-1996, Thomas G. Lane.
- * Modification developed 2003-2018 by Guido Vollbeding.
+ * Modification developed 2003-2015 by Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
@@ -3261,84 +3261,78 @@ jpeg_fdct_6x3 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 GLOBAL(void)
 jpeg_fdct_4x2 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 {
-  DCTELEM tmp0, tmp2, tmp10, tmp12, tmp4, tmp5;
-  INT32 tmp1, tmp3, tmp11, tmp13;
-  INT32 z1, z2, z3;
+  INT32 tmp0, tmp1;
+  INT32 tmp10, tmp11;
+  DCTELEM *dataptr;
  JSAMPROW elemptr;
+  int ctr;
  SHIFT_TEMPS

  /* Pre-zero output coefficient block. */
  MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);

  /* Pass 1: process rows.
-   * Note results are scaled up by sqrt(8) compared to a true DCT.
+   * Note results are scaled up by sqrt(8) compared to a true DCT;
+   * furthermore, we scale the results by 2**PASS1_BITS.
+   * We must also scale the output by (8/4)*(8/2) = 2**3, which we add here.
   * 4-point FDCT kernel,
   * cK represents sqrt(2) * cos(K*pi/16) [refers to 8-point FDCT].
   */

-  /* Row 0 */
-  elemptr = sample_data[0] + start_col;
+  dataptr = data;
+  for (ctr = 0; ctr < 2; ctr++) {
+    elemptr = sample_data[ctr] + start_col;

-  /* Even part */
+    /* Even part */

-  tmp4 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[3]);
-  tmp5 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[2]);
+    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[3]);
+    tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[2]);

-  tmp0 = tmp4 + tmp5;
-  tmp2 = tmp4 - tmp5;
+    tmp10 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[3]);
+    tmp11 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[2]);

-  /* Odd part */
+    /* Apply unsigned->signed conversion. */
+    dataptr[0] = (DCTELEM)
+      ((tmp0 + tmp1 - 4 * CENTERJSAMPLE) << (PASS1_BITS+3));
+    dataptr[2] = (DCTELEM) ((tmp0 - tmp1) << (PASS1_BITS+3));

-  z2 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[3]);
-  z3 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[2]);
+    /* Odd part */

-  z1 = MULTIPLY(z2 + z3, FIX_0_541196100);    /* c6 */
-  /* Add fudge factor here for final descale. */
-  z1 += ONE << (CONST_BITS-3-1);
-  tmp1 = z1 + MULTIPLY(z2, FIX_0_765366865); /* c2-c6 */
-  tmp3 = z1 - MULTIPLY(z3, FIX_1_847759065); /* c2+c6 */
+    tmp0 = MULTIPLY(tmp10 + tmp11, FIX_0_541196100);       /* c6 */
+    /* Add fudge factor here for final descale. */
+    tmp0 += ONE << (CONST_BITS-PASS1_BITS-4);

-  /* Row 1 */
-  elemptr = sample_data[1] + start_col;
+    dataptr[1] = (DCTELEM)
+      RIGHT_SHIFT(tmp0 + MULTIPLY(tmp10, FIX_0_765366865), /* c2-c6 */
+		  CONST_BITS-PASS1_BITS-3);
+    dataptr[3] = (DCTELEM)
+      RIGHT_SHIFT(tmp0 - MULTIPLY(tmp11, FIX_1_847759065), /* c2+c6 */
+		  CONST_BITS-PASS1_BITS-3);

-  /* Even part */
-
-  tmp4 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[3]);
-  tmp5 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[2]);
-
-  tmp10 = tmp4 + tmp5;
-  tmp12 = tmp4 - tmp5;
-
-  /* Odd part */
-
-  z2 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[3]);
-  z3 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[2]);
-
-  z1 = MULTIPLY(z2 + z3, FIX_0_541196100);    /* c6 */
-  tmp11 = z1 + MULTIPLY(z2, FIX_0_765366865); /* c2-c6 */
-  tmp13 = z1 - MULTIPLY(z3, FIX_1_847759065); /* c2+c6 */
+    dataptr += DCTSIZE;		/* advance pointer to next row */
+  }

  /* Pass 2: process columns.
-   * We leave the results scaled up by an overall factor of 8.
-   * We must also scale the output by (8/4)*(8/2) = 2**3.
+   * We remove the PASS1_BITS scaling, but leave the results scaled up
+   * by an overall factor of 8.
   */

-  /* Column 0 */
-  /* Apply unsigned->signed conversion. */
-  data[DCTSIZE*0] = (tmp0 + tmp10 - 8 * CENTERJSAMPLE) << 3;
-  data[DCTSIZE*1] = (tmp0 - tmp10) << 3;
+  dataptr = data;
+  for (ctr = 0; ctr < 4; ctr++) {
+    /* Even part */

-  /* Column 1 */
-  data[DCTSIZE*0+1] = (DCTELEM) RIGHT_SHIFT(tmp1 + tmp11, CONST_BITS-3);
-  data[DCTSIZE*1+1] = (DCTELEM) RIGHT_SHIFT(tmp1 - tmp11, CONST_BITS-3);
+    /* Add fudge factor here for final descale. */
+    tmp0 = dataptr[DCTSIZE*0] + (ONE << (PASS1_BITS-1));
+    tmp1 = dataptr[DCTSIZE*1];

-  /* Column 2 */
-  data[DCTSIZE*0+2] = (tmp2 + tmp12) << 3;
-  data[DCTSIZE*1+2] = (tmp2 - tmp12) << 3;
+    dataptr[DCTSIZE*0] = (DCTELEM) RIGHT_SHIFT(tmp0 + tmp1, PASS1_BITS);

-  /* Column 3 */
-  data[DCTSIZE*0+3] = (DCTELEM) RIGHT_SHIFT(tmp3 + tmp13, CONST_BITS-3);
-  data[DCTSIZE*1+3] = (DCTELEM) RIGHT_SHIFT(tmp3 - tmp13, CONST_BITS-3);
+    /* Odd part */
+
+    dataptr[DCTSIZE*1] = (DCTELEM) RIGHT_SHIFT(tmp0 - tmp1, PASS1_BITS);
+
+    dataptr++;			/* advance pointer to next column */
+  }
 }


@@ -4318,6 +4312,7 @@ jpeg_fdct_2x4 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)

  /* Pass 1: process rows.
   * Note results are scaled up by sqrt(8) compared to a true DCT.
+   * We must also scale the output by (8/2)*(8/4) = 2**3, which we add here.
   */

  dataptr = data;
@@ -4330,18 +4325,17 @@ jpeg_fdct_2x4 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
    tmp1 = GETJSAMPLE(elemptr[1]);

    /* Apply unsigned->signed conversion. */
-    dataptr[0] = (DCTELEM) (tmp0 + tmp1 - 2 * CENTERJSAMPLE);
+    dataptr[0] = (DCTELEM) ((tmp0 + tmp1 - 2 * CENTERJSAMPLE) << 3);

    /* Odd part */

-    dataptr[1] = (DCTELEM) (tmp0 - tmp1);
+    dataptr[1] = (DCTELEM) ((tmp0 - tmp1) << 3);

    dataptr += DCTSIZE;		/* advance pointer to next row */
  }

  /* Pass 2: process columns.
   * We leave the results scaled up by an overall factor of 8.
-   * We must also scale the output by (8/2)*(8/4) = 2**3.
   * 4-point FDCT kernel,
   * cK represents sqrt(2) * cos(K*pi/16) [refers to 8-point FDCT].
   */
@@ -4356,21 +4350,21 @@ jpeg_fdct_2x4 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
    tmp10 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*3];
    tmp11 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*2];

-    dataptr[DCTSIZE*0] = (DCTELEM) ((tmp0 + tmp1) << 3);
-    dataptr[DCTSIZE*2] = (DCTELEM) ((tmp0 - tmp1) << 3);
+    dataptr[DCTSIZE*0] = (DCTELEM) (tmp0 + tmp1);
+    dataptr[DCTSIZE*2] = (DCTELEM) (tmp0 - tmp1);

    /* Odd part */

    tmp0 = MULTIPLY(tmp10 + tmp11, FIX_0_541196100);       /* c6 */
    /* Add fudge factor here for final descale. */
-    tmp0 += ONE << (CONST_BITS-3-1);
+    tmp0 += ONE << (CONST_BITS-1);

    dataptr[DCTSIZE*1] = (DCTELEM)
      RIGHT_SHIFT(tmp0 + MULTIPLY(tmp10, FIX_0_765366865), /* c2-c6 */
-		  CONST_BITS-3);
+		  CONST_BITS);
    dataptr[DCTSIZE*3] = (DCTELEM)
      RIGHT_SHIFT(tmp0 - MULTIPLY(tmp11, FIX_1_847759065), /* c2+c6 */
-		  CONST_BITS-3);
+		  CONST_BITS);

    dataptr++;			/* advance pointer to next column */
  }
@@ -2,7 +2,7 @@
 * jidctint.c
 *
 * Copyright (C) 1991-1998, Thomas G. Lane.
- * Modification developed 2002-2018 by Guido Vollbeding.
+ * Modification developed 2002-2016 by Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
@@ -1474,7 +1474,7 @@ jpeg_idct_10x10 (j_decompress_ptr cinfo, jpeg_component_info * compptr,

 /*
 * Perform dequantization and inverse DCT on one block of coefficients,
- * producing an 11x11 output block.
+ * producing a 11x11 output block.
 *
 * Optimized algorithm with 24 multiplications in the 1-D kernel.
 * cK represents sqrt(2) * cos(K*pi/22).
@@ -3675,7 +3675,7 @@ jpeg_idct_10x5 (j_decompress_ptr cinfo, jpeg_component_info * compptr,

 /*
 * Perform dequantization and inverse DCT on one block of coefficients,
- * producing an 8x4 output block.
+ * producing a 8x4 output block.
 *
 * 4-point IDCT in pass 1 (columns), 8-point in pass 2 (rows).
 */
@@ -3835,7 +3835,7 @@ jpeg_idct_8x4 (j_decompress_ptr cinfo, jpeg_component_info * compptr,

 /*
 * Perform dequantization and inverse DCT on one block of coefficients,
- * producing a 6x3 output block.
+ * producing a reduced-size 6x3 output block.
 *
 * 3-point IDCT in pass 1 (columns), 6-point in pass 2 (rows).
 */
@@ -4082,7 +4082,7 @@ jpeg_idct_2x1 (j_decompress_ptr cinfo, jpeg_component_info * compptr,

 /*
 * Perform dequantization and inverse DCT on one block of coefficients,
- * producing an 8x16 output block.
+ * producing a 8x16 output block.
 *
 * 16-point IDCT in pass 1 (columns), 8-point in pass 2 (rows).
 */
@@ -5004,7 +5004,7 @@ jpeg_idct_4x8 (j_decompress_ptr cinfo, jpeg_component_info * compptr,

 /*
 * Perform dequantization and inverse DCT on one block of coefficients,
- * producing a 3x6 output block.
+ * producing a reduced-size 3x6 output block.
 *
 * 6-point IDCT in pass 1 (columns), 3-point in pass 2 (rows).
 */
@@ -2,7 +2,7 @@
 * jmemmgr.c
 *
 * Copyright (C) 1991-1997, Thomas G. Lane.
- * Modified 2011-2019 by Guido Vollbeding.
+ * Modified 2011-2012 by Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
@@ -130,7 +130,7 @@ typedef struct {
  jvirt_barray_ptr virt_barray_list;

  /* This counts total space obtained from jpeg_get_small/large */
-  size_t total_space_allocated;
+  long total_space_allocated;

  /* alloc_sarray and alloc_barray set this value for use by virtual
   * array routines.
@@ -195,7 +195,7 @@ print_mem_stats (j_common_ptr cinfo, int pool_id)
   * This is helpful because message parm array can't handle longs.
   */
  fprintf(stderr, "Freeing pool %d, total space = %ld\n",
-	  pool_id, (long) mem->total_space_allocated);
+	  pool_id, mem->total_space_allocated);

  for (lhdr_ptr = mem->large_list[pool_id]; lhdr_ptr != NULL;
       lhdr_ptr = lhdr_ptr->hdr.next) {
@@ -260,11 +260,11 @@ alloc_small (j_common_ptr cinfo, int pool_id, size_t sizeofobject)
 {
  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
  small_pool_ptr hdr_ptr, prev_hdr_ptr;
-  size_t odd_bytes, min_request, slop;
  char * data_ptr;
+  size_t odd_bytes, min_request, slop;

  /* Check for unsatisfiable request (do now to ensure no overflow below) */
-  if (sizeofobject > (size_t) MAX_ALLOC_CHUNK - SIZEOF(small_pool_hdr))
+  if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(small_pool_hdr)))
    out_of_memory(cinfo, 1);	/* request exceeds malloc's ability */

  /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */
@@ -293,8 +293,8 @@ alloc_small (j_common_ptr cinfo, int pool_id, size_t sizeofobject)
    else
      slop = extra_pool_slop[pool_id];
    /* Don't ask for more than MAX_ALLOC_CHUNK */
-    if (slop > (size_t) MAX_ALLOC_CHUNK - min_request)
-      slop = (size_t) MAX_ALLOC_CHUNK - min_request;
+    if (slop > (size_t) (MAX_ALLOC_CHUNK-min_request))
+      slop = (size_t) (MAX_ALLOC_CHUNK-min_request);
    /* Try to get space, if fail reduce slop and try again */
    for (;;) {
      hdr_ptr = (small_pool_ptr) jpeg_get_small(cinfo, min_request + slop);
@@ -348,7 +348,7 @@ alloc_large (j_common_ptr cinfo, int pool_id, size_t sizeofobject)
  size_t odd_bytes;

  /* Check for unsatisfiable request (do now to ensure no overflow below) */
-  if (sizeofobject > (size_t) MAX_ALLOC_CHUNK - SIZEOF(large_pool_hdr))
+  if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)))
    out_of_memory(cinfo, 3);	/* request exceeds malloc's ability */

  /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */
@@ -404,7 +404,7 @@ alloc_sarray (j_common_ptr cinfo, int pool_id,
  long ltemp;

  /* Calculate max # of rows allowed in one allocation chunk */
-  ltemp = (MAX_ALLOC_CHUNK - SIZEOF(large_pool_hdr)) /
+  ltemp = (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)) /
 	  ((long) samplesperrow * SIZEOF(JSAMPLE));
  if (ltemp <= 0)
    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
@@ -416,14 +416,15 @@ alloc_sarray (j_common_ptr cinfo, int pool_id,

  /* Get space for row pointers (small object) */
  result = (JSAMPARRAY) alloc_small(cinfo, pool_id,
-				    (size_t) numrows * SIZEOF(JSAMPROW));
+				    (size_t) (numrows * SIZEOF(JSAMPROW)));

  /* Get the rows themselves (large objects) */
  currow = 0;
  while (currow < numrows) {
    rowsperchunk = MIN(rowsperchunk, numrows - currow);
    workspace = (JSAMPROW) alloc_large(cinfo, pool_id,
-      (size_t) rowsperchunk * (size_t) samplesperrow * SIZEOF(JSAMPLE));
+	(size_t) ((size_t) rowsperchunk * (size_t) samplesperrow
+		  * SIZEOF(JSAMPLE)));
    for (i = rowsperchunk; i > 0; i--) {
      result[currow++] = workspace;
      workspace += samplesperrow;
@@ -451,7 +452,7 @@ alloc_barray (j_common_ptr cinfo, int pool_id,
  long ltemp;

  /* Calculate max # of rows allowed in one allocation chunk */
-  ltemp = (MAX_ALLOC_CHUNK - SIZEOF(large_pool_hdr)) /
+  ltemp = (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)) /
 	  ((long) blocksperrow * SIZEOF(JBLOCK));
  if (ltemp <= 0)
    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
@@ -463,14 +464,15 @@ alloc_barray (j_common_ptr cinfo, int pool_id,

  /* Get space for row pointers (small object) */
  result = (JBLOCKARRAY) alloc_small(cinfo, pool_id,
-				     (size_t) numrows * SIZEOF(JBLOCKROW));
+				     (size_t) (numrows * SIZEOF(JBLOCKROW)));

  /* Get the rows themselves (large objects) */
  currow = 0;
  while (currow < numrows) {
    rowsperchunk = MIN(rowsperchunk, numrows - currow);
    workspace = (JBLOCKROW) alloc_large(cinfo, pool_id,
-      (size_t) rowsperchunk * (size_t) blocksperrow * SIZEOF(JBLOCK));
+	(size_t) ((size_t) rowsperchunk * (size_t) blocksperrow
+		  * SIZEOF(JBLOCK)));
    for (i = rowsperchunk; i > 0; i--) {
      result[currow++] = workspace;
      workspace += blocksperrow;
@@ -583,8 +585,8 @@ realize_virt_arrays (j_common_ptr cinfo)
 /* Allocate the in-memory buffers for any unrealized virtual arrays */
 {
  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
-  long bytesperrow, space_per_minheight, maximum_space;
-  long avail_mem, minheights, max_minheights;
+  long space_per_minheight, maximum_space, avail_mem;
+  long minheights, max_minheights;
  jvirt_sarray_ptr sptr;
  jvirt_barray_ptr bptr;

@@ -596,16 +598,18 @@ realize_virt_arrays (j_common_ptr cinfo)
  maximum_space = 0;
  for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) {
    if (sptr->mem_buffer == NULL) { /* if not realized yet */
-      bytesperrow = (long) sptr->samplesperrow * SIZEOF(JSAMPLE);
-      space_per_minheight += (long) sptr->maxaccess * bytesperrow;
-      maximum_space += (long) sptr->rows_in_array * bytesperrow;
+      space_per_minheight += (long) sptr->maxaccess *
+			     (long) sptr->samplesperrow * SIZEOF(JSAMPLE);
+      maximum_space += (long) sptr->rows_in_array *
+		       (long) sptr->samplesperrow * SIZEOF(JSAMPLE);
    }
  }
  for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) {
    if (bptr->mem_buffer == NULL) { /* if not realized yet */
-      bytesperrow = (long) bptr->blocksperrow * SIZEOF(JBLOCK);
-      space_per_minheight += (long) bptr->maxaccess * bytesperrow;
-      maximum_space += (long) bptr->rows_in_array * bytesperrow;
+      space_per_minheight += (long) bptr->maxaccess *
+			     (long) bptr->blocksperrow * SIZEOF(JBLOCK);
+      maximum_space += (long) bptr->rows_in_array *
+		       (long) bptr->blocksperrow * SIZEOF(JBLOCK);
    }
  }

@@ -614,7 +618,7 @@ realize_virt_arrays (j_common_ptr cinfo)

  /* Determine amount of memory to actually use; this is system-dependent. */
  avail_mem = jpeg_mem_available(cinfo, space_per_minheight, maximum_space,
-				 (long) mem->total_space_allocated);
+				 mem->total_space_allocated);

  /* If the maximum space needed is available, make all the buffers full
   * height; otherwise parcel it out with the same number of minheights
@@ -690,7 +694,7 @@ do_sarray_io (j_common_ptr cinfo, jvirt_sarray_ptr ptr, boolean writing)
  long bytesperrow, file_offset, byte_count, rows, thisrow, i;

  bytesperrow = (long) ptr->samplesperrow * SIZEOF(JSAMPLE);
-  file_offset = (long) ptr->cur_start_row * bytesperrow;
+  file_offset = ptr->cur_start_row * bytesperrow;
  /* Loop to read or write each allocation chunk in mem_buffer */
  for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) {
    /* One chunk, but check for short chunk at end of buffer */
@@ -723,7 +727,7 @@ do_barray_io (j_common_ptr cinfo, jvirt_barray_ptr ptr, boolean writing)
  long bytesperrow, file_offset, byte_count, rows, thisrow, i;

  bytesperrow = (long) ptr->blocksperrow * SIZEOF(JBLOCK);
-  file_offset = (long) ptr->cur_start_row * bytesperrow;
+  file_offset = ptr->cur_start_row * bytesperrow;
  /* Loop to read or write each allocation chunk in mem_buffer */
  for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) {
    /* One chunk, but check for short chunk at end of buffer */
@@ -767,7 +771,7 @@ access_virt_sarray (j_common_ptr cinfo, jvirt_sarray_ptr ptr,

  /* Make the desired part of the virtual array accessible */
  if (start_row < ptr->cur_start_row ||
-      end_row > ptr->cur_start_row + ptr->rows_in_mem) {
+      end_row > ptr->cur_start_row+ptr->rows_in_mem) {
    if (! ptr->b_s_open)
      ERREXIT(cinfo, JERR_VIRTUAL_BUG);
    /* Flush old buffer contents if necessary */
@@ -852,7 +856,7 @@ access_virt_barray (j_common_ptr cinfo, jvirt_barray_ptr ptr,

  /* Make the desired part of the virtual array accessible */
  if (start_row < ptr->cur_start_row ||
-      end_row > ptr->cur_start_row + ptr->rows_in_mem) {
+      end_row > ptr->cur_start_row+ptr->rows_in_mem) {
    if (! ptr->b_s_open)
      ERREXIT(cinfo, JERR_VIRTUAL_BUG);
    /* Flush old buffer contents if necessary */
@@ -1089,7 +1093,7 @@ jinit_memory_mgr (j_common_ptr cinfo)
  mem->total_space_allocated = SIZEOF(my_memory_mgr);

  /* Declare ourselves open for business */
-  cinfo->mem = &mem->pub;
+  cinfo->mem = & mem->pub;

  /* Check for an environment variable JPEGMEM; if found, override the
   * default max_memory setting from jpeg_mem_init.  Note that the
@@ -2,7 +2,6 @@
 * jmemnobs.c
 *
 * Copyright (C) 1992-1996, Thomas G. Lane.
- * Modified 2019 by Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
@@ -13,7 +12,7 @@
 * This is very portable in the sense that it'll compile on almost anything,
 * but you'd better have lots of main memory (or virtual memory) if you want
 * to process big images.
- * Note that the max_memory_to_use option is respected by this implementation.
+ * Note that the max_memory_to_use option is ignored by this implementation.
 */

 #define JPEG_INTERNALS
@@ -67,16 +66,13 @@ jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject)

 /*
 * This routine computes the total memory space available for allocation.
+ * Here we always say, "we got all you want bud!"
 */

 GLOBAL(long)
 jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed,
 		    long max_bytes_needed, long already_allocated)
 {
-  if (cinfo->mem->max_memory_to_use)
-    return cinfo->mem->max_memory_to_use - already_allocated;
-
-  /* Here we say, "we got all you want bud!" */
  return max_bytes_needed;
 }

@@ -2,7 +2,7 @@
 * jpegint.h
 *
 * Copyright (C) 1991-1997, Thomas G. Lane.
- * Modified 1997-2019 by Guido Vollbeding.
+ * Modified 1997-2017 by Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
@@ -302,13 +302,6 @@ struct jpeg_color_quantizer {
 #define RIGHT_SHIFT(x,shft)	((x) >> (shft))
 #endif

-/* Descale and correctly round an INT32 value that's scaled by N bits.
- * We assume RIGHT_SHIFT rounds towards minus infinity, so adding
- * the fudge factor is correct for either sign of X.
- */
-
-#define DESCALE(x,n)	RIGHT_SHIFT((x) + ((INT32) 1 << ((n)-1)), n)
-

 /* Short forms of external names for systems with brain-damaged linkers. */

@@ -2,7 +2,7 @@
 * jpeglib.h
 *
 * Copyright (C) 1991-1998, Thomas G. Lane.
- * Modified 2002-2019 by Guido Vollbeding.
+ * Modified 2002-2017 by Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
@@ -39,7 +39,7 @@ extern "C" {

 #define JPEG_LIB_VERSION        90	/* Compatibility version 9.0 */
 #define JPEG_LIB_VERSION_MAJOR  9
-#define JPEG_LIB_VERSION_MINOR  4
+#define JPEG_LIB_VERSION_MINOR  3


 /* Various constants determining the sizes of things.
@@ -909,7 +909,6 @@ typedef JMETHOD(boolean, jpeg_marker_parser_method, (j_decompress_ptr cinfo));
 #define jpeg_suppress_tables	jSuppressTables
 #define jpeg_alloc_quant_table	jAlcQTable
 #define jpeg_alloc_huff_table	jAlcHTable
-#define jpeg_std_huff_table	jStdHTable
 #define jpeg_start_compress	jStrtCompress
 #define jpeg_write_scanlines	jWrtScanlines
 #define jpeg_finish_compress	jFinCompress
@@ -978,10 +977,10 @@ EXTERN(void) jpeg_stdio_src JPP((j_decompress_ptr cinfo, FILE * infile));
 /* Data source and destination managers: memory buffers. */
 EXTERN(void) jpeg_mem_dest JPP((j_compress_ptr cinfo,
 			       unsigned char ** outbuffer,
-			       size_t * outsize));
+			       unsigned long * outsize));
 EXTERN(void) jpeg_mem_src JPP((j_decompress_ptr cinfo,
 			      const unsigned char * inbuffer,
-			      size_t insize));
+			      unsigned long insize));

 /* Default parameter setup for compression */
 EXTERN(void) jpeg_set_defaults JPP((j_compress_ptr cinfo));
@@ -1006,8 +1005,6 @@ EXTERN(void) jpeg_suppress_tables JPP((j_compress_ptr cinfo,
 				       boolean suppress));
 EXTERN(JQUANT_TBL *) jpeg_alloc_quant_table JPP((j_common_ptr cinfo));
 EXTERN(JHUFF_TBL *) jpeg_alloc_huff_table JPP((j_common_ptr cinfo));
-EXTERN(JHUFF_TBL *) jpeg_std_huff_table JPP((j_common_ptr cinfo,
-					     boolean isDC, int tblno));

 /* Main entry points for compression */
 EXTERN(void) jpeg_start_compress JPP((j_compress_ptr cinfo,
@@ -2,7 +2,7 @@
 * jutils.c
 *
 * Copyright (C) 1991-1996, Thomas G. Lane.
- * Modified 2009-2019 by Guido Vollbeding.
+ * Modified 2009-2011 by Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
@@ -185,7 +185,7 @@ jcopy_sample_rows (JSAMPARRAY input_array, int source_row,
 {
  register JSAMPROW inptr, outptr;
 #ifdef FMEMCOPY
-  register size_t count = (size_t) num_cols * SIZEOF(JSAMPLE);
+  register size_t count = (size_t) (num_cols * SIZEOF(JSAMPLE));
 #else
  register JDIMENSION count;
 #endif
@@ -213,7 +213,7 @@ jcopy_block_row (JBLOCKROW input_row, JBLOCKROW output_row,
 /* Copy a row of coefficient blocks from one place to another. */
 {
 #ifdef FMEMCOPY
-  FMEMCOPY(output_row, input_row, (size_t) num_blocks * (DCTSIZE2 * SIZEOF(JCOEF)));
+  FMEMCOPY(output_row, input_row, num_blocks * (DCTSIZE2 * SIZEOF(JCOEF)));
 #else
  register JCOEFPTR inptr, outptr;
  register long count;
@@ -1,7 +1,7 @@
 /*
 * jversion.h
 *
- * Copyright (C) 1991-2020, Thomas G. Lane, Guido Vollbeding.
+ * Copyright (C) 1991-2018, Thomas G. Lane, Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
@@ -9,6 +9,6 @@
 */


-#define JVERSION	"9d  12-Jan-2020"
+#define JVERSION	"9c  14-Jan-2018"

-#define JCOPYRIGHT	"Copyright (C) 2020, Thomas G. Lane, Guido Vollbeding"
+#define JCOPYRIGHT	"Copyright (C) 2018, Thomas G. Lane, Guido Vollbeding"
@@ -22,7 +22,7 @@
 #         sqfu@openailab.com
 #

-SET(TENGINE_COMMIT_VERSION "8a4c58e0e05cd850f4bb0936a330edc86dc0e28c")
+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}")

@@ -34,7 +34,7 @@ IF(EXISTS "${OCV_TENGINE_SOURCE_PATH}")
 ELSE()
 	SET(OCV_TENGINE_FILENAME "${TENGINE_COMMIT_VERSION}.zip")#name2
 	SET(OCV_TENGINE_URL "https://github.com/OAID/Tengine/archive/") #url2
-	SET(tengine_md5sum f51ca8f3963faeeff3f019a6f6edc206) #md5sum2
+	SET(tengine_md5sum 9124324b6e2b350012e46ae1db4bad7d) #md5sum2

 	#MESSAGE(STATUS "**** TENGINE DOWNLOAD BEGIN ****")
 	ocv_download(FILENAME ${OCV_TENGINE_FILENAME}
@@ -69,6 +69,7 @@ if(BUILD_TENGINE)
 	   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)
@@ -76,6 +77,7 @@ if(BUILD_TENGINE)
 		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 .
@@ -84,6 +86,6 @@ if(BUILD_TENGINE)
 		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()
-	SET(Tengine_LIB "tengine" CACHE INTERNAL "")
 endif()
@@ -63,7 +63,7 @@ Attribute::~Attribute () {}

 namespace {

-struct NameCompare
+struct NameCompare: std::binary_function <const char *, const char *, bool>
 {
    bool
    operator () (const char *x, const char *y) const
@@ -225,9 +225,7 @@ class TextFormat::Parser::ParserImpl {
             bool allow_unknown_enum,
             bool allow_field_number,
             bool allow_relaxed_whitespace,
-             bool allow_partial,
-             int recursion_limit  // backported from 3.8.0
-    )
+             bool allow_partial)
    : error_collector_(error_collector),
      finder_(finder),
      parse_info_tree_(parse_info_tree),
@@ -240,9 +238,7 @@ class TextFormat::Parser::ParserImpl {
      allow_unknown_enum_(allow_unknown_enum),
      allow_field_number_(allow_field_number),
      allow_partial_(allow_partial),
-      had_errors_(false),
-      recursion_limit_(recursion_limit)  // backported from 3.8.0
-    {
+      had_errors_(false) {
    // For backwards-compatibility with proto1, we need to allow the 'f' suffix
    // for floats.
    tokenizer_.set_allow_f_after_float(true);
@@ -494,9 +490,9 @@ class TextFormat::Parser::ParserImpl {
      if (TryConsume(":") && !LookingAt("{") && !LookingAt("<")) {
        UnknownFieldSet* unknown_field = unknown_fields->AddGroup(unknown_fields->field_count());
        unknown_field->AddLengthDelimited(0, field_name);  // Add a field's name.
-        return SkipFieldValue(unknown_field, recursion_limit_);
+        return SkipFieldValue(unknown_field);
      } else {
-        return SkipFieldMessage(unknown_fields, recursion_limit_);
+        return SkipFieldMessage(unknown_fields);
      }
    }

@@ -579,14 +575,7 @@ label_skip_parsing:
  }

  // Skips the next field including the field's name and value.
-  bool SkipField(UnknownFieldSet* unknown_fields, int recursion_limit) {
-
-    // OpenCV specific
-    if (--recursion_limit < 0) {
-      ReportError("Message is too deep (SkipField)");
-      return false;
-    }
-
+  bool SkipField(UnknownFieldSet* unknown_fields) {
    string field_name;
    if (TryConsume("[")) {
      // Extension name.
@@ -605,9 +594,9 @@ label_skip_parsing:
    if (TryConsume(":") && !LookingAt("{") && !LookingAt("<")) {
      UnknownFieldSet* unknown_field = unknown_fields->AddGroup(unknown_fields->field_count());
      unknown_field->AddLengthDelimited(0, field_name);  // Add a field's name.
-      DO(SkipFieldValue(unknown_field, recursion_limit));
+      DO(SkipFieldValue(unknown_field));
    } else {
-      DO(SkipFieldMessage(unknown_fields, recursion_limit));
+      DO(SkipFieldMessage(unknown_fields));
    }
    // For historical reasons, fields may optionally be separated by commas or
    // semicolons.
@@ -619,12 +608,6 @@ label_skip_parsing:
                           const Reflection* reflection,
                           const FieldDescriptor* field) {

-    // backported from 3.8.0
-    if (--recursion_limit_ < 0) {
-      ReportError("Message is too deep");
-      return false;
-    }
-
    // If the parse information tree is not NULL, create a nested one
    // for the nested message.
    ParseInfoTree* parent = parse_info_tree_;
@@ -641,9 +624,6 @@ label_skip_parsing:
                        delimiter));
    }

-    // backported from 3.8.0
-    ++recursion_limit_;
-
    // Reset the parse information tree.
    parse_info_tree_ = parent;
    return true;
@@ -651,17 +631,11 @@ label_skip_parsing:

  // Skips the whole body of a message including the beginning delimiter and
  // the ending delimiter.
-  bool SkipFieldMessage(UnknownFieldSet* unknown_fields, int recursion_limit) {
-    // OpenCV specific
-    if (--recursion_limit < 0) {
-      ReportError("Message is too deep (SkipFieldMessage)");
-      return false;
-    }
-
+  bool SkipFieldMessage(UnknownFieldSet* unknown_fields) {
    string delimiter;
    DO(ConsumeMessageDelimiter(&delimiter));
    while (!LookingAt(">") &&  !LookingAt("}")) {
-      DO(SkipField(unknown_fields, recursion_limit));
+      DO(SkipField(unknown_fields));
    }
    DO(Consume(delimiter));
    return true;
@@ -801,14 +775,7 @@ label_skip_parsing:
    return true;
  }

-  bool SkipFieldValue(UnknownFieldSet* unknown_field, int recursion_limit) {
-
-    // OpenCV specific
-    if (--recursion_limit < 0) {
-      ReportError("Message is too deep (SkipFieldValue)");
-      return false;
-    }
-
+  bool SkipFieldValue(UnknownFieldSet* unknown_field) {
    if (LookingAtType(io::Tokenizer::TYPE_STRING)) {
      while (LookingAtType(io::Tokenizer::TYPE_STRING)) {
        tokenizer_.Next();
@@ -818,9 +785,9 @@ label_skip_parsing:
    if (TryConsume("[")) {
      while (true) {
        if (!LookingAt("{") && !LookingAt("<")) {
-          DO(SkipFieldValue(unknown_field, recursion_limit));
+          DO(SkipFieldValue(unknown_field));
        } else {
-          DO(SkipFieldMessage(unknown_field, recursion_limit));
+          DO(SkipFieldMessage(unknown_field));
        }
        if (TryConsume("]")) {
          break;
@@ -1189,7 +1156,6 @@ label_skip_parsing:
  const bool allow_field_number_;
  const bool allow_partial_;
  bool had_errors_;
-  int recursion_limit_;  // backported from 3.8.0
 };

 #undef DO
@@ -1340,19 +1306,17 @@ class TextFormat::Printer::TextGenerator
 TextFormat::Finder::~Finder() {
 }

-TextFormat::Parser::Parser()
+TextFormat::Parser::Parser(bool allow_unknown_field)
  : error_collector_(NULL),
    finder_(NULL),
    parse_info_tree_(NULL),
    allow_partial_(false),
    allow_case_insensitive_field_(false),
-    allow_unknown_field_(false),
+    allow_unknown_field_(allow_unknown_field),
    allow_unknown_enum_(false),
    allow_field_number_(false),
    allow_relaxed_whitespace_(false),
-    allow_singular_overwrites_(false),
-    recursion_limit_(std::numeric_limits<int>::max())
-{
+    allow_singular_overwrites_(false) {
 }

 TextFormat::Parser::~Parser() {}
@@ -1371,7 +1335,7 @@ bool TextFormat::Parser::Parse(io::ZeroCopyInputStream* input,
                    overwrites_policy,
                    allow_case_insensitive_field_, allow_unknown_field_,
                    allow_unknown_enum_, allow_field_number_,
-                    allow_relaxed_whitespace_, allow_partial_, recursion_limit_);
+                    allow_relaxed_whitespace_, allow_partial_);
  return MergeUsingImpl(input, output, &parser);
 }

@@ -1389,7 +1353,7 @@ bool TextFormat::Parser::Merge(io::ZeroCopyInputStream* input,
                    ParserImpl::ALLOW_SINGULAR_OVERWRITES,
                    allow_case_insensitive_field_, allow_unknown_field_,
                    allow_unknown_enum_, allow_field_number_,
-                    allow_relaxed_whitespace_, allow_partial_, recursion_limit_);
+                    allow_relaxed_whitespace_, allow_partial_);
  return MergeUsingImpl(input, output, &parser);
 }

@@ -1424,7 +1388,7 @@ bool TextFormat::Parser::ParseFieldValueFromString(
                    ParserImpl::ALLOW_SINGULAR_OVERWRITES,
                    allow_case_insensitive_field_, allow_unknown_field_,
                    allow_unknown_enum_, allow_field_number_,
-                    allow_relaxed_whitespace_, allow_partial_, recursion_limit_);
+                    allow_relaxed_whitespace_, allow_partial_);
  return parser.ParseField(field, output);
 }

@@ -457,7 +457,7 @@ class LIBPROTOBUF_EXPORT TextFormat {
  // For more control over parsing, use this class.
  class LIBPROTOBUF_EXPORT Parser {
   public:
-    Parser();
+    Parser(bool allow_unknown_field = false);
    ~Parser();

    // Like TextFormat::Parse().
@@ -508,24 +508,10 @@ class LIBPROTOBUF_EXPORT TextFormat {
                                   Message* output);


-    // backported from 3.8.0
-    // When an unknown field is met, parsing will fail if this option is set
-    // to false(the default). If true, unknown fields will be ignored and
-    // a warning message will be generated.
-    // Please aware that set this option true may hide some errors (e.g.
-    // spelling error on field name). Avoid to use this option if possible.
-    void AllowUnknownField(bool allow) { allow_unknown_field_ = allow; }
-
-
    void AllowFieldNumber(bool allow) {
      allow_field_number_ = allow;
    }

-    // backported from 3.8.0
-    // Sets maximum recursion depth which parser can use. This is effectively
-    // the maximum allowed nesting of proto messages.
-    void SetRecursionLimit(int limit) { recursion_limit_ = limit; }
-
   private:
    // Forward declaration of an internal class used to parse text
    // representations (see text_format.cc for implementation).
@@ -547,7 +533,6 @@ class LIBPROTOBUF_EXPORT TextFormat {
    bool allow_field_number_;
    bool allow_relaxed_whitespace_;
    bool allow_singular_overwrites_;
-    int recursion_limit_;  // backported from 3.8.0
  };


@@ -32,10 +32,8 @@
 #define QUIRC_PERSPECTIVE_PARAMS	8

 #if QUIRC_MAX_REGIONS < UINT8_MAX
-#define QUIRC_PIXEL_ALIAS_IMAGE	1
 typedef uint8_t quirc_pixel_t;
 #elif QUIRC_MAX_REGIONS < UINT16_MAX
-#define QUIRC_PIXEL_ALIAS_IMAGE	0
 typedef uint16_t quirc_pixel_t;
 #else
 #error "QUIRC_MAX_REGIONS > 65534 is not supported"
@@ -79,6 +77,7 @@ struct quirc_grid {
 struct quirc {
 	uint8_t			*image;
 	quirc_pixel_t		*pixels;
+	int			*row_average; /* used by threshold() */
 	int			w;
 	int			h;

@@ -874,7 +874,7 @@ static quirc_decode_error_t decode_payload(struct quirc_data *data,
 done:

 	/* Add nul terminator to all payloads */
-	if (data->payload_len >= (int) sizeof(data->payload))
+	if ((unsigned)data->payload_len >= sizeof(data->payload))
 		data->payload_len--;
 	data->payload[data->payload_len] = 0;

@@ -27,7 +27,10 @@ struct quirc *quirc_new(void)
 {
 	struct quirc *q = malloc(sizeof(*q));

-    memset(q, 0, sizeof(*q));
+	if (!q)
+		return NULL;
+
+	memset(q, 0, sizeof(*q));
 	return q;
 }

@@ -36,8 +39,9 @@ void quirc_destroy(struct quirc *q)
 	free(q->image);
 	/* q->pixels may alias q->image when their type representation is of the
 	   same size, so we need to be careful here to avoid a double free */
-	if (!QUIRC_PIXEL_ALIAS_IMAGE)
+	if (sizeof(*q->image) != sizeof(*q->pixels))
 		free(q->pixels);
+	free(q->row_average);
 	free(q);
 }

@@ -45,6 +49,7 @@ int quirc_resize(struct quirc *q, int w, int h)
 {
 	uint8_t		*image  = NULL;
 	quirc_pixel_t	*pixels = NULL;
+	int		*row_average = NULL;

 	/*
 	 * XXX: w and h should be size_t (or at least unsigned) as negatives
@@ -77,27 +82,35 @@ int quirc_resize(struct quirc *q, int w, int h)
 	(void)memcpy(image, q->image, min);

 	/* alloc a new buffer for q->pixels if needed */
-	if (!QUIRC_PIXEL_ALIAS_IMAGE) {
+	if (sizeof(*q->image) != sizeof(*q->pixels)) {
 		pixels = calloc(newdim, sizeof(quirc_pixel_t));
 		if (!pixels)
 			goto fail;
 	}

+	/* alloc a new buffer for q->row_average */
+	row_average = calloc(w, sizeof(int));
+	if (!row_average)
+		goto fail;
+
 	/* alloc succeeded, update `q` with the new size and buffers */
 	q->w = w;
 	q->h = h;
 	free(q->image);
 	q->image = image;
-	if (!QUIRC_PIXEL_ALIAS_IMAGE) {
+	if (sizeof(*q->image) != sizeof(*q->pixels)) {
 		free(q->pixels);
 		q->pixels = pixels;
 	}
+	free(q->row_average);
+	q->row_average = row_average;

 	return 0;
 	/* NOTREACHED */
 fail:
 	free(image);
 	free(pixels);
+	free(row_average);

 	return -1;
 }
@@ -120,10 +133,6 @@ static const char *const error_table[] = {

 const char *quirc_strerror(quirc_decode_error_t err)
 {
-    if ((int) err >= 0) {
-        if ((unsigned long) err < (unsigned long) (sizeof(error_table) / sizeof(error_table[0])))
-            return error_table[err];
-    }
-
-    return "Unknown error";
+	if ((int)err < 8) { return error_table[err]; }
+	else { return "Unknown error"; }
 }
@@ -17,7 +17,16 @@
 #include <quirc_internal.h>

 const struct quirc_version_info quirc_version_db[QUIRC_MAX_VERSION + 1] = {
-	    {0},
+			{ /* 0 */
+				.data_bytes = 0,
+				.apat = {0},
+				.ecc = {
+					{.bs = 0, .dw = 0, .ns = 0},
+					{.bs = 0, .dw = 0, .ns = 0},
+					{.bs = 0, .dw = 0, .ns = 0},
+					{.bs = 0, .dw = 0, .ns = 0}
+				}
+			},
 	    { /* Version 1 */
 		    .data_bytes = 26,
 		    .apat = {0},
@@ -5,8 +5,8 @@ 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.2")
-ocv_update(OPENCV_TBB_RELEASE_MD5 "5af6f6c2a24c2043e62e47205e273b1f")
+ocv_update(OPENCV_TBB_RELEASE "v2020.1")
+ocv_update(OPENCV_TBB_RELEASE_MD5 "734f335d06ee80a7d4a20cc0da734c59")
 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 ...)
@@ -285,12 +285,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)
@@ -452,7 +449,6 @@ OCV_OPTION(BUILD_FAT_JAVA_LIB       "Create Java wrapper exporting all functions
 OCV_OPTION(BUILD_ANDROID_SERVICE    "Build OpenCV Manager for Google Play" OFF IF ANDROID )
 OCV_OPTION(BUILD_CUDA_STUBS         "Build CUDA modules stubs when no CUDA SDK" OFF  IF (NOT APPLE_FRAMEWORK) )
 OCV_OPTION(BUILD_JAVA               "Enable Java support"                         (ANDROID OR NOT CMAKE_CROSSCOMPILING)  IF (ANDROID OR (NOT APPLE_FRAMEWORK AND NOT WINRT)) )
-OCV_OPTION(BUILD_OBJC               "Enable Objective-C support"                  ON  IF APPLE_FRAMEWORK )

 # OpenCV installation options
 # ===================================================
@@ -947,11 +943,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()
@@ -1253,12 +1249,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)
@@ -1596,12 +1588,6 @@ if(BUILD_JAVA)
  status("    Java tests:"    BUILD_TESTS AND opencv_test_java_BINARY_DIR                                 THEN YES ELSE NO)
 endif()

-# ========================== Objective-C =======================
-if(BUILD_OBJC)
-  status("")
-  status("  Objective-C wrappers:" HAVE_opencv_objc                                                       THEN YES ELSE NO)
-endif()
-
 ocv_cmake_hook(STATUS_DUMP_EXTRA)

 # ========================== auxiliary ==========================
@@ -1617,10 +1603,6 @@ if(ENABLE_CONFIG_VERIFICATION)
  ocv_verify_config()
 endif()

-if(HAVE_CUDA AND COMMAND CUDA_BUILD_CLEAN_TARGET)
-  CUDA_BUILD_CLEAN_TARGET()
-endif()
-
 ocv_cmake_hook(POST_FINALIZE)

 # ----------------------------------------------------------------------------
@@ -3,12 +3,10 @@
 ### Resources

 * Homepage: <https://opencv.org>
-  * Courses: <https://opencv.org/courses>
 * Docs: <https://docs.opencv.org/master/>
 * Q&A forum: <http://answers.opencv.org>
 * Issue tracking: <https://github.com/opencv/opencv/issues>

-
 ### Contributing

 Please read the [contribution guidelines](https://github.com/opencv/opencv/wiki/How_to_contribute) before starting work on a pull request.
@@ -65,11 +65,7 @@ endif()

 # extract version from the include
 if(CUDNN_INCLUDE_DIR)
-  if(EXISTS "${CUDNN_INCLUDE_DIR}/cudnn_version.h")
-    file(READ "${CUDNN_INCLUDE_DIR}/cudnn_version.h" CUDNN_H_CONTENTS)
-  else()
-    file(READ "${CUDNN_INCLUDE_DIR}/cudnn.h" CUDNN_H_CONTENTS)
-  endif()
+  file(READ "${CUDNN_INCLUDE_DIR}/cudnn.h" CUDNN_H_CONTENTS)

  string(REGEX MATCH "define CUDNN_MAJOR ([0-9]+)" _ "${CUDNN_H_CONTENTS}")
  set(CUDNN_MAJOR_VERSION ${CMAKE_MATCH_1} CACHE INTERNAL "")
@@ -191,6 +191,7 @@ if(CV_GCC OR CV_CLANG)

  # Profiling?
  if(ENABLE_PROFILING)
+    add_extra_compiler_option("-pg -g")
    # turn off incompatible options
    foreach(flags CMAKE_CXX_FLAGS CMAKE_C_FLAGS CMAKE_CXX_FLAGS_RELEASE CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_DEBUG CMAKE_C_FLAGS_DEBUG
                  OPENCV_EXTRA_FLAGS_RELEASE OPENCV_EXTRA_FLAGS_DEBUG OPENCV_EXTRA_C_FLAGS OPENCV_EXTRA_CXX_FLAGS)
@@ -198,9 +199,6 @@ if(CV_GCC OR CV_CLANG)
      string(REPLACE "-ffunction-sections" "" ${flags} "${${flags}}")
      string(REPLACE "-fdata-sections" "" ${flags} "${${flags}}")
    endforeach()
-    # -pg should be placed both in the linker and in the compiler settings
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -pg")
-    add_extra_compiler_option("-pg -g")
  else()
    if(MSVC)
      # TODO: Clang/C2 is not supported
@@ -1,14 +1,13 @@
-if((WIN32 AND NOT MSVC) OR OPENCV_CMAKE_FORCE_CUDA)
+if(WIN32 AND NOT MSVC)
  message(STATUS "CUDA compilation is disabled (due to only Visual Studio compiler supported on your platform).")
  return()
 endif()

-if((NOT UNIX AND CV_CLANG) OR OPENCV_CMAKE_FORCE_CUDA)
+if(NOT UNIX AND CV_CLANG)
  message(STATUS "CUDA compilation is disabled (due to Clang unsupported on your platform).")
  return()
 endif()

-#set(OPENCV_CMAKE_CUDA_DEBUG 1)

 if(((NOT CMAKE_VERSION VERSION_LESS "3.9.0")  # requires https://gitlab.kitware.com/cmake/cmake/merge_requests/663
      OR OPENCV_CUDA_FORCE_EXTERNAL_CMAKE_MODULE)
@@ -29,11 +28,6 @@ endif()

 if(CUDA_FOUND)
  set(HAVE_CUDA 1)
-  if(NOT CUDA_VERSION VERSION_LESS 11.0)
-    # CUDA 11.0 removes nppicom
-    ocv_list_filterout(CUDA_nppi_LIBRARY "nppicom")
-    ocv_list_filterout(CUDA_npp_LIBRARY "nppicom")
-  endif()

  if(WITH_CUFFT)
    set(HAVE_CUFFT 1)
@@ -54,31 +48,11 @@ if(CUDA_FOUND)
  endif()

  if(WITH_NVCUVID)
-    macro(ocv_cuda_SEARCH_NVCUVID_HEADER _filename _result)
-      # place header file under CUDA_TOOLKIT_TARGET_DIR or CUDA_TOOLKIT_ROOT_DIR
-      find_path(_header_result
-        ${_filename}
-        PATHS "${CUDA_TOOLKIT_TARGET_DIR}" "${CUDA_TOOLKIT_ROOT_DIR}"
-        ENV CUDA_PATH
-        ENV CUDA_INC_PATH
-        PATH_SUFFIXES include
-        NO_DEFAULT_PATH
-        )
-      if("x${_header_result}" STREQUAL "x_header_result-NOTFOUND")
-        set(${_result} 0)
-      else()
-        set(${_result} 1)
-      endif()
-      unset(_header_result CACHE)
-    endmacro()
-    ocv_cuda_SEARCH_NVCUVID_HEADER("nvcuvid.h" HAVE_NVCUVID_HEADER)
-    ocv_cuda_SEARCH_NVCUVID_HEADER("dynlink_nvcuvid.h" HAVE_DYNLINK_NVCUVID_HEADER)
    find_cuda_helper_libs(nvcuvid)
    if(WIN32)
      find_cuda_helper_libs(nvcuvenc)
    endif()
-    if(CUDA_nvcuvid_LIBRARY AND (${HAVE_NVCUVID_HEADER} OR ${HAVE_DYNLINK_NVCUVID_HEADER}))
-      # make sure to have both header and library before enabling
+    if(CUDA_nvcuvid_LIBRARY)
      set(HAVE_NVCUVID 1)
    endif()
    if(CUDA_nvcuvenc_LIBRARY)
@@ -88,14 +62,7 @@ if(CUDA_FOUND)

  message(STATUS "CUDA detected: " ${CUDA_VERSION})

-  set(_generations "Fermi" "Kepler" "Maxwell" "Pascal" "Volta" "Turing" "Ampere")
-  set(_arch_fermi   "2.0")
-  set(_arch_kepler  "3.0;3.5;3.7")
-  set(_arch_maxwell "5.0;5.2")
-  set(_arch_pascal  "6.0;6.1")
-  set(_arch_volta   "7.0")
-  set(_arch_turing  "7.5")
-  set(_arch_ampere  "8.0")
+  set(_generations "Fermi" "Kepler" "Maxwell" "Pascal" "Volta" "Turing")
  if(NOT CMAKE_CROSSCOMPILING)
    list(APPEND _generations "Auto")
  endif()
@@ -113,131 +80,37 @@ if(CUDA_FOUND)
    unset(CUDA_ARCH_PTX CACHE)
  endif()

-  if(OPENCV_CUDA_DETECTION_NVCC_FLAGS MATCHES "-ccbin")
-    # already specified by user
-  elseif(CUDA_HOST_COMPILER AND EXISTS "${CUDA_HOST_COMPILER}")
-    get_filename_component(c_compiler_realpath "${CMAKE_C_COMPILER}" REALPATH)
-    # C compiler doesn't work with --run option, forcing C++ compiler instead
-    if(CUDA_HOST_COMPILER STREQUAL c_compiler_realpath OR CUDA_HOST_COMPILER STREQUAL CMAKE_C_COMPILER)
-      if(DEFINED CMAKE_CXX_COMPILER)
-        get_filename_component(cxx_compiler_realpath "${CMAKE_CXX_COMPILER}" REALPATH)
-        LIST(APPEND OPENCV_CUDA_DETECTION_NVCC_FLAGS -ccbin "${cxx_compiler_realpath}")
-      else()
-        message(STATUS "CUDA: CMAKE_CXX_COMPILER is not available. You may need to specify CUDA_HOST_COMPILER.")
-      endif()
-    else()
-      LIST(APPEND OPENCV_CUDA_DETECTION_NVCC_FLAGS -ccbin "${CUDA_HOST_COMPILER}")
-    endif()
-  elseif(WIN32 AND CMAKE_LINKER) # Workaround for VS cl.exe not being in the env. path
+  SET(DETECT_ARCHS_COMMAND "${CUDA_NVCC_EXECUTABLE}" ${CUDA_NVCC_FLAGS} "${OpenCV_SOURCE_DIR}/cmake/checks/OpenCVDetectCudaArch.cu" "--run")
+  if(WIN32 AND CMAKE_LINKER) #Workaround for VS cl.exe not being in the env. path
    get_filename_component(host_compiler_bindir ${CMAKE_LINKER} DIRECTORY)
-    LIST(APPEND OPENCV_CUDA_DETECTION_NVCC_FLAGS -ccbin "${host_compiler_bindir}")
-  else()
-    if(CUDA_HOST_COMPILER)
-      message(STATUS "CUDA: CUDA_HOST_COMPILER='${CUDA_HOST_COMPILER}' is not valid, autodetection may not work. Specify OPENCV_CUDA_DETECTION_NVCC_FLAGS with -ccbin option for fix that")
-    endif()
+    SET(DETECT_ARCHS_COMMAND ${DETECT_ARCHS_COMMAND} "-ccbin" "${host_compiler_bindir}")
  endif()

-  macro(ocv_filter_available_architecture result_list)
-    set(__cache_key_check "${ARGN} : ${CUDA_NVCC_EXECUTABLE} ${OPENCV_CUDA_DETECTION_NVCC_FLAGS}")
-    if(DEFINED OPENCV_CACHE_CUDA_SUPPORTED_CC AND OPENCV_CACHE_CUDA_SUPPORTED_CC_check STREQUAL __cache_key_check)
-      set(${result_list} "${OPENCV_CACHE_CUDA_SUPPORTED_CC}")
-    else()
-      set(CC_LIST ${ARGN})
-      foreach(target_arch ${CC_LIST})
-        string(REPLACE "." "" target_arch_short "${target_arch}")
-        set(NVCC_OPTION "-gencode;arch=compute_${target_arch_short},code=sm_${target_arch_short}")
-        set(_cmd "${CUDA_NVCC_EXECUTABLE}" ${OPENCV_CUDA_DETECTION_NVCC_FLAGS} ${NVCC_OPTION} "${OpenCV_SOURCE_DIR}/cmake/checks/OpenCVDetectCudaArch.cu" --compile)
-        execute_process(
-            COMMAND ${_cmd}
-            WORKING_DIRECTORY "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/"
-            RESULT_VARIABLE _nvcc_res
-            OUTPUT_VARIABLE _nvcc_out
-            ERROR_VARIABLE _nvcc_err
-            #ERROR_QUIET
-            OUTPUT_STRIP_TRAILING_WHITESPACE
-        )
-        if(OPENCV_CMAKE_CUDA_DEBUG)
-          message(WARNING "COMMAND: ${_cmd}")
-          message(STATUS "Result: ${_nvcc_res}")
-          message(STATUS "Out: ${_nvcc_out}")
-          message(STATUS "Err: ${_nvcc_err}")
-        endif()
-        if(_nvcc_res EQUAL 0)
-          LIST(APPEND ${result_list} "${target_arch}")
-        endif()
-      endforeach()
-      string(STRIP "${${result_list}}" ${result_list})
-      if(" ${${result_list}}" STREQUAL " ")
-        message(WARNING "CUDA: Autodetection arch list is empty. Please enable OPENCV_CMAKE_CUDA_DEBUG=1 and check/specify OPENCV_CUDA_DETECTION_NVCC_FLAGS variable")
-      endif()
-
-      # cache detected values
-      set(OPENCV_CACHE_CUDA_SUPPORTED_CC ${${result_list}} CACHE INTERNAL "")
-      set(OPENCV_CACHE_CUDA_SUPPORTED_CC_check "${__cache_key_check}" CACHE INTERNAL "")
-    endif()
-  endmacro()
-
-  macro(ocv_detect_native_cuda_arch status output)
-    set(OPENCV_CUDA_DETECT_ARCHS_COMMAND "${CUDA_NVCC_EXECUTABLE}" ${OPENCV_CUDA_DETECTION_NVCC_FLAGS} "${OpenCV_SOURCE_DIR}/cmake/checks/OpenCVDetectCudaArch.cu" "--run")
-    set(__cache_key_check "${OPENCV_CUDA_DETECT_ARCHS_COMMAND}")
-    if(DEFINED OPENCV_CACHE_CUDA_ACTIVE_CC AND OPENCV_CACHE_CUDA_ACTIVE_CC_check STREQUAL __cache_key_check)
-      set(${output} "${OPENCV_CACHE_CUDA_ACTIVE_CC}")
-      set(${status} 0)
-    else()
-      execute_process(
-          COMMAND ${OPENCV_CUDA_DETECT_ARCHS_COMMAND}
-          WORKING_DIRECTORY "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/"
-          RESULT_VARIABLE ${status}
-          OUTPUT_VARIABLE _nvcc_out
-          ERROR_VARIABLE _nvcc_err
-          ERROR_QUIET
-          OUTPUT_STRIP_TRAILING_WHITESPACE
-      )
-      if(OPENCV_CMAKE_CUDA_DEBUG)
-        message(WARNING "COMMAND: ${OPENCV_CUDA_DETECT_ARCHS_COMMAND}")
-        message(STATUS "Result: ${${status}}")
-        message(STATUS "Out: ${_nvcc_out}")
-        message(STATUS "Err: ${_nvcc_err}")
-      endif()
-      string(REGEX REPLACE ".*\n" "" ${output} "${_nvcc_out}") #Strip leading warning messages, if any
-
-      if(${status} EQUAL 0)
-        # cache detected values
-        set(OPENCV_CACHE_CUDA_ACTIVE_CC ${${result_list}} CACHE INTERNAL "")
-        set(OPENCV_CACHE_CUDA_ACTIVE_CC_check "${__cache_key_check}" CACHE INTERNAL "")
-      endif()
-    endif()
-  endmacro()
-
-  macro(ocv_wipeout_deprecated _arch_bin_list)
-    string(REPLACE "2.1" "2.1(2.0)" ${_arch_bin_list} "${${_arch_bin_list}}")
-  endmacro()
-
  set(__cuda_arch_ptx "")
  if(CUDA_GENERATION STREQUAL "Fermi")
-    set(__cuda_arch_bin ${_arch_fermi})
+    set(__cuda_arch_bin "2.0")
  elseif(CUDA_GENERATION STREQUAL "Kepler")
-    set(__cuda_arch_bin ${_arch_kepler})
+    set(__cuda_arch_bin "3.0 3.5 3.7")
  elseif(CUDA_GENERATION STREQUAL "Maxwell")
-    set(__cuda_arch_bin ${_arch_maxwell})
+    set(__cuda_arch_bin "5.0 5.2")
  elseif(CUDA_GENERATION STREQUAL "Pascal")
-    set(__cuda_arch_bin ${_arch_pascal})
+    set(__cuda_arch_bin "6.0 6.1")
  elseif(CUDA_GENERATION STREQUAL "Volta")
-    set(__cuda_arch_bin ${_arch_volta})
+    set(__cuda_arch_bin "7.0")
  elseif(CUDA_GENERATION STREQUAL "Turing")
-    set(__cuda_arch_bin ${_arch_turing})
-  elseif(CUDA_GENERATION STREQUAL "Ampere")
-    set(__cuda_arch_bin ${_arch_ampere})
+    set(__cuda_arch_bin "7.5")
  elseif(CUDA_GENERATION STREQUAL "Auto")
-    ocv_detect_native_cuda_arch(_nvcc_res _nvcc_out)
+    execute_process( COMMAND ${DETECT_ARCHS_COMMAND}
+                     WORKING_DIRECTORY "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/"
+                     RESULT_VARIABLE _nvcc_res OUTPUT_VARIABLE _nvcc_out
+                     ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+    string(REGEX REPLACE ".*\n" "" _nvcc_out "${_nvcc_out}") #Strip leading warning messages, if any
    if(NOT _nvcc_res EQUAL 0)
      message(STATUS "Automatic detection of CUDA generation failed. Going to build for all known architectures.")
    else()
-      string(REGEX MATCHALL "[0-9]+\\.[0-9]" __cuda_arch_bin "${_nvcc_out}")
+      set(__cuda_arch_bin "${_nvcc_out}")
+      string(REPLACE "2.1" "2.1(2.0)" __cuda_arch_bin "${__cuda_arch_bin}")
    endif()
-  elseif(CUDA_ARCH_BIN)
-    message(STATUS "CUDA: Using CUDA_ARCH_BIN=${CUDA_ARCH_BIN}")
-    set(__cuda_arch_bin ${CUDA_ARCH_BIN})
  endif()

  if(NOT DEFINED __cuda_arch_bin)
@@ -245,37 +118,29 @@ if(CUDA_FOUND)
      set(__cuda_arch_bin "3.2")
      set(__cuda_arch_ptx "")
    elseif(AARCH64)
-      if(NOT CMAKE_CROSSCOMPILING)
-        ocv_detect_native_cuda_arch(_nvcc_res _nvcc_out)
-      else()
-        set(_nvcc_res -1)  # emulate error, see below
-      endif()
+      execute_process( COMMAND ${DETECT_ARCHS_COMMAND}
+                       WORKING_DIRECTORY "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/"
+                       RESULT_VARIABLE _nvcc_res OUTPUT_VARIABLE _nvcc_out
+                       ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+      string(REGEX REPLACE ".*\n" "" _nvcc_out "${_nvcc_out}") #Strip leading warning messages, if any
      if(NOT _nvcc_res EQUAL 0)
        message(STATUS "Automatic detection of CUDA generation failed. Going to build for all known architectures.")
-        # TX1 (5.3) TX2 (6.2) Xavier (7.2) V100 (7.0)
-        ocv_filter_available_architecture(__cuda_arch_bin
-            5.3
-            6.2
-            7.2
-            7.0
-        )
+        set(__cuda_arch_bin "5.3 6.2 7.2")
      else()
        set(__cuda_arch_bin "${_nvcc_out}")
+        string(REPLACE "2.1" "2.1(2.0)" __cuda_arch_bin "${__cuda_arch_bin}")
      endif()
      set(__cuda_arch_ptx "")
    else()
-      ocv_filter_available_architecture(__cuda_arch_bin
-          ${_arch_fermi}
-          ${_arch_kepler}
-          ${_arch_maxwell}
-          ${_arch_pascal}
-          ${_arch_volta}
-          ${_arch_turing}
-          ${_arch_ampere}
-      )
+      if(CUDA_VERSION VERSION_LESS "9.0")
+        set(__cuda_arch_bin "2.0 3.0 3.5 3.7 5.0 5.2 6.0 6.1")
+      elseif(CUDA_VERSION VERSION_LESS "10.0")
+        set(__cuda_arch_bin "3.0 3.5 3.7 5.0 5.2 6.0 6.1 7.0")
+      else()
+        set(__cuda_arch_bin "3.0 3.5 3.7 5.0 5.2 6.0 6.1 7.0 7.5")
+      endif()
    endif()
  endif()
-  ocv_wipeout_deprecated(__cuda_arch_bin)

  set(CUDA_ARCH_BIN ${__cuda_arch_bin} CACHE STRING "Specify 'real' GPU architectures to build binaries for, BIN(PTX) format is supported")
  set(CUDA_ARCH_PTX ${__cuda_arch_ptx} CACHE STRING "Specify 'virtual' PTX architectures to build PTX intermediate code for")
@@ -283,9 +148,11 @@ if(CUDA_FOUND)
  string(REGEX REPLACE "\\." "" ARCH_BIN_NO_POINTS "${CUDA_ARCH_BIN}")
  string(REGEX REPLACE "\\." "" ARCH_PTX_NO_POINTS "${CUDA_ARCH_PTX}")

-  # Check if user specified 1.0 compute capability: we don't support it
-  if(" ${CUDA_ARCH_BIN} ${CUDA_ARCH_PTX}" MATCHES " 1.0")
-    message(SEND_ERROR "CUDA: 1.0 compute capability is not supported - exclude it from ARCH/PTX list are re-run CMake")
+  # Ckeck if user specified 1.0 compute capability: we don't support it
+  string(REGEX MATCH "1.0" HAS_ARCH_10 "${CUDA_ARCH_BIN} ${CUDA_ARCH_PTX}")
+  set(CUDA_ARCH_BIN_OR_PTX_10 0)
+  if(NOT ${HAS_ARCH_10} STREQUAL "")
+    set(CUDA_ARCH_BIN_OR_PTX_10 1)
  endif()

  # NVCC flags to be set
@@ -395,14 +262,7 @@ if(CUDA_FOUND)
    endif()

    if(UNIX OR APPLE)
-      set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} -Xcompiler -fPIC)
-      if(NOT " ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_RELEASE} ${CMAKE_CXX_FLAGS_DEBUG} ${CUDA_NVCC_FLAGS}" MATCHES "-std=")
-        if(CUDA_VERSION VERSION_LESS "11.0")
-          list(APPEND CUDA_NVCC_FLAGS "--std=c++11")
-        else()
-          list(APPEND CUDA_NVCC_FLAGS "--std=c++14")
-        endif()
-      endif()
+      set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} -Xcompiler -fPIC --std=c++11)
    endif()
    if(APPLE)
      set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} -Xcompiler -fno-finite-math-only)
@@ -476,13 +336,6 @@ if(HAVE_CUDA)
    set(CUDA_cufft_LIBRARY_ABS ${CUDA_cufft_LIBRARY})
    ocv_convert_to_lib_name(CUDA_cufft_LIBRARY ${CUDA_cufft_LIBRARY})
  endif()
-
-  if(CMAKE_GENERATOR MATCHES "Visual Studio"
-      AND NOT OPENCV_SKIP_CUDA_CMAKE_SUPPRESS_REGENERATION
-  )
-    message(STATUS "CUDA: MSVS generator is detected. Disabling CMake re-run checks (CMAKE_SUPPRESS_REGENERATION=ON). You need to run CMake manually if updates are required.")
-    set(CMAKE_SUPPRESS_REGENERATION ON)
-  endif()
 endif()


@@ -98,8 +98,6 @@ elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)64")
  set(PPC64 1)
 elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(mips.*|MIPS.*)")
  set(MIPS 1)
-elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(riscv.*|RISCV.*)")
-  set(RISCV 1)
 else()
  if(NOT OPENCV_SUPPRESS_MESSAGE_UNRECOGNIZED_SYSTEM_PROCESSOR)
    message(WARNING "OpenCV: unrecognized target processor configuration")
@@ -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}"
@@ -54,31 +30,24 @@ function(add_custom_ie_build _inc _lib _lib_rel _lib_dbg _msg)
  )

  set(custom_libraries "")
-  set(__prefixes "${CMAKE_FIND_LIBRARY_PREFIXES}")
-  if(NOT __prefixes)
-    set(__prefixes "_empty_")
-  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()
+  file(GLOB libraries "${INF_ENGINE_LIB_DIRS}/${CMAKE_SHARED_LIBRARY_PREFIX}inference_engine_*${CMAKE_SHARED_LIBRARY_SUFFIX}")
+  foreach(full_path IN LISTS libraries)
+    get_filename_component(library "${full_path}" NAME_WE)
+    string(REPLACE "${CMAKE_SHARED_LIBRARY_PREFIX}" "" library "${library}")
+    add_library(${library} UNKNOWN IMPORTED)
+    set_target_properties(${library} PROPERTIES
+      IMPORTED_LOCATION "${full_path}")
+    list(APPEND custom_libraries ${library})
  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)
  message(STATUS "Detected InferenceEngine: ${_msg}")
@@ -95,9 +64,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 +82,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)
@@ -129,9 +92,9 @@ endif()

 if(INF_ENGINE_TARGET)
  if(NOT INF_ENGINE_RELEASE)
-    message(WARNING "InferenceEngine version has not been set, 2020.4 will be used by default. Set INF_ENGINE_RELEASE variable if you experience build errors.")
+    message(WARNING "InferenceEngine version has not been set, 2020.2 will be used by default. Set INF_ENGINE_RELEASE variable if you experience build errors.")
  endif()
-  set(INF_ENGINE_RELEASE "2020040000" CACHE STRING "Force IE version, should be in form YYYYAABBCC (e.g. 2020.1.0.2 -> 2020010002)")
+  set(INF_ENGINE_RELEASE "2020020000" CACHE STRING "Force IE version, should be in form YYYYAABBCC (e.g. 2020.1.0.2 -> 2020010002)")
  set_target_properties(${INF_ENGINE_TARGET} PROPERTIES
    INTERFACE_COMPILE_DEFINITIONS "HAVE_INF_ENGINE=1;INF_ENGINE_RELEASE=${INF_ENGINE_RELEASE}"
  )
@@ -1,30 +1,12 @@
-# VTK 9.0
-if(NOT VTK_FOUND)
-  find_package(VTK 9 QUIET NAMES vtk COMPONENTS
-    FiltersExtraction
-    FiltersSources
-    FiltersTexture
-    IOExport
-    IOGeometry
-    IOPLY
-    InteractionStyle
-    RenderingCore
-    RenderingLOD
-    RenderingOpenGL2
-    NO_MODULE)
-endif()
-
 # VTK 6.x components
-if(NOT VTK_FOUND)
-  find_package(VTK QUIET COMPONENTS vtkInteractionStyle vtkRenderingLOD vtkIOPLY vtkFiltersTexture vtkRenderingFreeType vtkIOExport NO_MODULE)
-  IF(VTK_FOUND)
-    IF(VTK_RENDERING_BACKEND) #in vtk 7, the rendering backend is exported as a var.
+find_package(VTK QUIET COMPONENTS vtkInteractionStyle vtkRenderingLOD vtkIOPLY vtkFiltersTexture vtkRenderingFreeType vtkIOExport NO_MODULE)
+IF(VTK_FOUND)
+  IF(VTK_RENDERING_BACKEND) #in vtk 7, the rendering backend is exported as a var.
      find_package(VTK QUIET COMPONENTS vtkRendering${VTK_RENDERING_BACKEND} vtkInteractionStyle vtkRenderingLOD vtkIOPLY vtkFiltersTexture vtkRenderingFreeType vtkIOExport vtkIOGeometry NO_MODULE)
-    ELSE(VTK_RENDERING_BACKEND)
+  ELSE(VTK_RENDERING_BACKEND)
      find_package(VTK QUIET COMPONENTS vtkRenderingOpenGL vtkInteractionStyle vtkRenderingLOD vtkIOPLY vtkFiltersTexture vtkRenderingFreeType vtkIOExport NO_MODULE)
-    ENDIF(VTK_RENDERING_BACKEND)
-  ENDIF(VTK_FOUND)
-endif()
+  ENDIF(VTK_RENDERING_BACKEND)
+ENDIF(VTK_FOUND)

 # VTK 5.x components
 if(NOT VTK_FOUND)
@@ -1,22 +1,17 @@
 # ----------------------------------------------------------------------------
 #   Uninstall target, for "make uninstall"
 # ----------------------------------------------------------------------------
-if(NOT TARGET uninstall)  # avoid conflicts with parent projects
-  configure_file(
-      "${OpenCV_SOURCE_DIR}/cmake/templates/cmake_uninstall.cmake.in"
-      "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
-      @ONLY
-  )
+CONFIGURE_FILE(
+  "${OpenCV_SOURCE_DIR}/cmake/templates/cmake_uninstall.cmake.in"
+  "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
+  @ONLY)

-  add_custom_target(uninstall
-      COMMAND "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
-  )
-
-  if(ENABLE_SOLUTION_FOLDERS)
-    set_target_properties(uninstall PROPERTIES FOLDER "CMakeTargets")
-  endif()
+ADD_CUSTOM_TARGET(uninstall "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")
+if(ENABLE_SOLUTION_FOLDERS)
+  set_target_properties(uninstall PROPERTIES FOLDER "CMakeTargets")
 endif()

+
 # ----------------------------------------------------------------------------
 # target building all OpenCV modules
 # ----------------------------------------------------------------------------
@@ -148,7 +148,7 @@ macro(ipp_detect_version)
          IMPORTED_LOCATION ${IPP_LIBRARY_DIR}/${IPP_LIB_PREFIX}${IPP_PREFIX}${name}${IPP_SUFFIX}${IPP_LIB_SUFFIX}
        )
        list(APPEND IPP_LIBRARIES ipp${name})
-        if (NOT BUILD_SHARED_LIBS AND (HAVE_IPP_ICV OR ";${OPENCV_INSTALL_EXTERNAL_DEPENDENCIES};" MATCHES ";ipp;"))
+        if (NOT BUILD_SHARED_LIBS)
          # CMake doesn't support "install(TARGETS ${IPP_PREFIX}${name} " command with imported targets
          install(FILES ${IPP_LIBRARY_DIR}/${IPP_LIB_PREFIX}${IPP_PREFIX}${name}${IPP_SUFFIX}${IPP_LIB_SUFFIX}
                  DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev)
@@ -108,13 +108,12 @@ macro(ippiw_setup PATH BUILD)
          message(STATUS "found Intel IPP Integration Wrappers binaries: ${IW_VERSION_MAJOR}.${IW_VERSION_MINOR}.${IW_VERSION_UPDATE}")
          message(STATUS "at: ${IPP_IW_PATH}")

-          add_library(ipp_iw STATIC IMPORTED)
-          set_target_properties(ipp_iw PROPERTIES
+          add_library(ippiw STATIC IMPORTED)
+          set_target_properties(ippiw PROPERTIES
            IMPORTED_LINK_INTERFACE_LIBRARIES ""
            IMPORTED_LOCATION "${FILE}"
          )
-
-          if (NOT BUILD_SHARED_LIBS AND ";${OPENCV_INSTALL_EXTERNAL_DEPENDENCIES};" MATCHES ";ipp;")
+          if (NOT BUILD_SHARED_LIBS)
            # CMake doesn't support "install(TARGETS ${name} ...)" command with imported targets
            install(FILES "${FILE}"
                    DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev)
@@ -123,7 +122,7 @@ macro(ippiw_setup PATH BUILD)
          endif()

          set(IPP_IW_INCLUDES "${IPP_IW_PATH}/include")
-          set(IPP_IW_LIBRARIES ipp_iw)
+          set(IPP_IW_LIBRARIES ippiw)

          set(HAVE_IPP_IW 1)
          set(BUILD_IPP_IW 0)
@@ -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()
@@ -79,10 +79,9 @@ get_mkl_version(${MKL_INCLUDE_DIRS}/mkl_version.h)

 #determine arch
 if(CMAKE_CXX_SIZEOF_DATA_PTR EQUAL 8)
-    set(MKL_ARCH_LIST "intel64")
-    if(MSVC)
-        list(APPEND MKL_ARCH_LIST "win-x64")
-    endif()
+    set(MKL_X64 1)
+    set(MKL_ARCH "intel64")
+
    include(CheckTypeSize)
    CHECK_TYPE_SIZE(int _sizeof_int)
    if (_sizeof_int EQUAL 4)
@@ -91,19 +90,14 @@ if(CMAKE_CXX_SIZEOF_DATA_PTR EQUAL 8)
        set(MKL_ARCH_SUFFIX "ilp64")
    endif()
 else()
-    set(MKL_ARCH_LIST "ia32")
+    set(MKL_ARCH "ia32")
    set(MKL_ARCH_SUFFIX "c")
 endif()

 if(MKL_VERSION_STR VERSION_GREATER "11.3.0" OR MKL_VERSION_STR VERSION_EQUAL "11.3.0")
    set(mkl_lib_find_paths
-        ${MKL_ROOT_DIR}/lib)
-    foreach(MKL_ARCH ${MKL_ARCH_LIST})
-      list(APPEND mkl_lib_find_paths
-        ${MKL_ROOT_DIR}/lib/${MKL_ARCH}
-        ${MKL_ROOT_DIR}/../tbb/lib/${MKL_ARCH}
-        ${MKL_ROOT_DIR}/${MKL_ARCH})
-    endforeach()
+        ${MKL_ROOT_DIR}/lib
+        ${MKL_ROOT_DIR}/lib/${MKL_ARCH} ${MKL_ROOT_DIR}/../tbb/lib/${MKL_ARCH})

    set(mkl_lib_list "mkl_intel_${MKL_ARCH_SUFFIX}")

@@ -127,7 +121,7 @@ endif()

 set(MKL_LIBRARIES "")
 foreach(lib ${mkl_lib_list})
-    find_library(${lib} NAMES ${lib} ${lib}_dll HINTS ${mkl_lib_find_paths})
+    find_library(${lib} ${lib} ${mkl_lib_find_paths})
    mark_as_advanced(${lib})
    if(NOT ${lib})
        mkl_fail()
@@ -46,7 +46,6 @@
 SET(Open_BLAS_INCLUDE_SEARCH_PATHS
  $ENV{OpenBLAS_HOME}
  $ENV{OpenBLAS_HOME}/include
-  $ENV{OpenBLAS_HOME}/include/openblas
  /opt/OpenBLAS/include
  /usr/local/include/openblas
  /usr/include/openblas
@@ -104,4 +103,4 @@ MARK_AS_ADVANCED(
    OpenBLAS_INCLUDE_DIR
    OpenBLAS_LIB
    OpenBLAS
-)
+)
@@ -88,7 +88,7 @@ FOREACH(SEARCH_PATH ${SEARCH_PATHS})
    ocv_find_openexr("-${OPENEXR_VERSION}")
    ocv_find_openexr("-${OPENEXR_VERSION}_s")
    ocv_find_openexr("-${OPENEXR_VERSION}_d")
-    ocv_find_openexr("-${OPENEXR_VERSION}_s_d")
+    ocv_find_openexr("-${OPEXEXR_VERSION}_s_d")
    ocv_find_openexr("")
    ocv_find_openexr("_s")
    ocv_find_openexr("_d")
@@ -6,15 +6,9 @@ if(NOT WITH_PROTOBUF)
  return()
 endif()

-ocv_option(BUILD_PROTOBUF "Force to build libprotobuf runtime from sources" ON)
+ocv_option(BUILD_PROTOBUF "Force to build libprotobuf from sources" ON)
 ocv_option(PROTOBUF_UPDATE_FILES "Force rebuilding .proto files (protoc should be available)" OFF)

-# BUILD_PROTOBUF=OFF: Custom manual protobuf configuration (see find_package(Protobuf) for details):
-# - Protobuf_INCLUDE_DIR
-# - Protobuf_LIBRARY
-# - Protobuf_PROTOC_EXECUTABLE
-
-
 function(get_protobuf_version version include)
  file(STRINGS "${include}/google/protobuf/stubs/common.h" ver REGEX "#define GOOGLE_PROTOBUF_VERSION [0-9]+")
  string(REGEX MATCHALL "[0-9]+" ver ${ver})
@@ -25,9 +19,7 @@ function(get_protobuf_version version include)
 endfunction()

 if(BUILD_PROTOBUF)
-  ocv_assert(NOT PROTOBUF_UPDATE_FILES)
  add_subdirectory("${OpenCV_SOURCE_DIR}/3rdparty/protobuf")
-  set(Protobuf_LIBRARIES "libprotobuf")
  set(HAVE_PROTOBUF TRUE)
 else()
  unset(Protobuf_VERSION CACHE)
@@ -52,7 +44,10 @@ else()

  if(Protobuf_FOUND)
    if(TARGET protobuf::libprotobuf)
-      set(Protobuf_LIBRARIES "protobuf::libprotobuf")
+      add_library(libprotobuf INTERFACE IMPORTED)
+      set_target_properties(libprotobuf PROPERTIES
+        INTERFACE_LINK_LIBRARIES protobuf::libprotobuf
+      )
    else()
      add_library(libprotobuf UNKNOWN IMPORTED)
      set_target_properties(libprotobuf PROPERTIES
@@ -61,31 +56,21 @@ else()
        INTERFACE_SYSTEM_INCLUDE_DIRECTORIES "${Protobuf_INCLUDE_DIR}"
      )
      get_protobuf_version(Protobuf_VERSION "${Protobuf_INCLUDE_DIR}")
-      set(Protobuf_LIBRARIES "libprotobuf")
    endif()
    set(HAVE_PROTOBUF TRUE)
  endif()
 endif()

 if(HAVE_PROTOBUF AND PROTOBUF_UPDATE_FILES AND NOT COMMAND PROTOBUF_GENERATE_CPP)
-  message(FATAL_ERROR "Can't configure protobuf dependency (BUILD_PROTOBUF=${BUILD_PROTOBUF} PROTOBUF_UPDATE_FILES=${PROTOBUF_UPDATE_FILES})")
+  find_package(Protobuf QUIET)
+  if(NOT COMMAND PROTOBUF_GENERATE_CPP)
+    message(FATAL_ERROR "PROTOBUF_GENERATE_CPP command is not available")
+  endif()
 endif()

 if(HAVE_PROTOBUF)
  list(APPEND CUSTOM_STATUS protobuf)
-  if(NOT BUILD_PROTOBUF)
-    if(TARGET "${Protobuf_LIBRARIES}")
-      get_target_property(__location "${Protobuf_LIBRARIES}" IMPORTED_LOCATION_RELEASE)
-      if(NOT __location)
-        get_target_property(__location "${Protobuf_LIBRARIES}" IMPORTED_LOCATION)
-      endif()
-    elseif(Protobuf_LIBRARY)
-      set(__location "${Protobuf_LIBRARY}")
-    else()
-      set(__location "${Protobuf_LIBRARIES}")
-    endif()
-  endif()
  list(APPEND CUSTOM_STATUS_protobuf "    Protobuf:"
    BUILD_PROTOBUF THEN "build (${Protobuf_VERSION})"
-    ELSE "${__location} (${Protobuf_VERSION})")
+    ELSE "${Protobuf_LIBRARY} (${Protobuf_VERSION})")
 endif()
@@ -5,9 +5,10 @@
 # VA_INTEL_IOCL_ROOT - root of Intel OCL installation

 if(UNIX AND NOT ANDROID)
-    ocv_check_environment_variables(VA_INTEL_IOCL_ROOT)
-    if(NOT DEFINED VA_INTEL_IOCL_ROOT)
-      set(VA_INTEL_IOCL_ROOT "/opt/intel/opencl")
+    if($ENV{VA_INTEL_IOCL_ROOT})
+        set(VA_INTEL_IOCL_ROOT $ENV{VA_INTEL_IOCL_ROOT})
+    else()
+        set(VA_INTEL_IOCL_ROOT "/opt/intel/opencl")
    endif()

    find_path(
@@ -30,11 +30,6 @@ if(BUILD_FAT_JAVA_LIB AND HAVE_opencv_java)
  list(APPEND OPENCV_MODULES_CONFIGCMAKE opencv_java)
 endif()

-if(BUILD_OBJC AND HAVE_opencv_objc)
-  list(APPEND OPENCV_MODULES_CONFIGCMAKE opencv_objc)
-endif()
-
-
 # -------------------------------------------------------------------------------------------
 #  Part 1/3: ${BIN_DIR}/OpenCVConfig.cmake              -> For use *without* "make install"
 # -------------------------------------------------------------------------------------------
@@ -2,7 +2,7 @@ set(OPENCV_APPLE_BUNDLE_NAME "OpenCV")
 set(OPENCV_APPLE_BUNDLE_ID "org.opencv")

 if(IOS)
-  if (APPLE_FRAMEWORK AND DYNAMIC_PLIST)
+  if (APPLE_FRAMEWORK AND BUILD_SHARED_LIBS)
    configure_file("${OpenCV_SOURCE_DIR}/platforms/ios/Info.Dynamic.plist.in"
                   "${CMAKE_BINARY_DIR}/ios/Info.plist")
  else()
@@ -788,7 +788,6 @@ macro(ocv_glob_module_sources)
  if (APPLE)
    file(GLOB_RECURSE lib_srcs_apple
         "${CMAKE_CURRENT_LIST_DIR}/src/*.mm"
-         "${CMAKE_CURRENT_LIST_DIR}/src/*.swift"
    )
    list(APPEND lib_srcs ${lib_srcs_apple})
  endif()
@@ -1088,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 "")
@@ -1139,12 +1127,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
@@ -1229,12 +1212,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
@@ -1,28 +1,25 @@
 # -----------------------------------------------
 # File that provides "make uninstall" target
 #  We use the file 'install_manifest.txt'
-#
-# Details: https://gitlab.kitware.com/cmake/community/-/wikis/FAQ#can-i-do-make-uninstall-with-cmake
 # -----------------------------------------------
+IF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
+  MESSAGE(FATAL_ERROR "Cannot find install manifest: \"@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt\"")
+ENDIF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")

-if(NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt")
-  message(FATAL_ERROR "Cannot find install manifest: \"@CMAKE_BINARY_DIR@/install_manifest.txt\"")
-endif()
-
-file(READ "@CMAKE_BINARY_DIR@/install_manifest.txt" files)
-string(REGEX REPLACE "\n" ";" files "${files}")
-foreach(file ${files})
-  message(STATUS "Uninstalling $ENV{DESTDIR}${file}")
-  if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
-    exec_program(
-        "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
-        OUTPUT_VARIABLE rm_out
-        RETURN_VALUE rm_retval
-    )
-    if(NOT "${rm_retval}" STREQUAL 0)
-      message(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}")
-    endif()
-  else(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
-    message(STATUS "File $ENV{DESTDIR}${file} does not exist.")
-  endif()
-endforeach()
+FILE(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files)
+STRING(REGEX REPLACE "\n" ";" files "${files}")
+FOREACH(file ${files})
+  MESSAGE(STATUS "Uninstalling \"$ENV{DESTDIR}${file}\"")
+  IF(EXISTS "$ENV{DESTDIR}${file}")
+    EXEC_PROGRAM(
+      "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
+      OUTPUT_VARIABLE rm_out
+      RETURN_VALUE rm_retval
+      )
+    IF(NOT "${rm_retval}" STREQUAL 0)
+      MESSAGE(FATAL_ERROR "Problem when removing \"$ENV{DESTDIR}${file}\"")
+    ENDIF(NOT "${rm_retval}" STREQUAL 0)
+  ELSE(EXISTS "$ENV{DESTDIR}${file}")
+    MESSAGE(STATUS "File \"$ENV{DESTDIR}${file}\" does not exist.")
+  ENDIF(EXISTS "$ENV{DESTDIR}${file}")
+ENDFOREACH(file)
@@ -13,6 +13,9 @@
 /* Compile for 'real' NVIDIA GPU architectures */
 #define CUDA_ARCH_BIN "${OPENCV_CUDA_ARCH_BIN}"

+/* Create PTX or BIN for 1.0 compute capability */
+#cmakedefine CUDA_ARCH_BIN_OR_PTX_10
+
 /* NVIDIA GPU features are used */
 #define CUDA_ARCH_FEATURES "${OPENCV_CUDA_ARCH_FEATURES}"

@@ -78,7 +81,6 @@
 #cmakedefine HAVE_IPP_IW_LL

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

 /* IJG JPEG codec */
@@ -92,8 +94,6 @@

 /* NVIDIA Video Decoding API*/
 #cmakedefine HAVE_NVCUVID
-#cmakedefine HAVE_NVCUVID_HEADER
-#cmakedefine HAVE_DYNLINK_NVCUVID_HEADER

 /* NVIDIA Video Encoding API*/
 #cmakedefine HAVE_NVCUVENC
@@ -3,11 +3,12 @@
 prefix=@prefix@
 exec_prefix=@exec_prefix@
 libdir=@libdir@
-includedir=@includedir@
+includedir_old=@includedir@/opencv
+includedir_new=@includedir@

 Name: OpenCV
 Description: Open Source Computer Vision Library
 Version: @OPENCV_VERSION_PLAIN@
 Libs: @OPENCV_PC_LIBS@
 Libs.private: @OPENCV_PC_LIBS_PRIVATE@
-Cflags: -I${includedir}
+Cflags: -I${includedir_old} -I${includedir_new}
@@ -246,7 +246,7 @@ PREDEFINED             = __cplusplus=1 \
                         CV_WRAP_PHANTOM(x)= \
                         CV_WRAP_DEFAULT(x)= \
                         CV_CDECL= \
-                         CV_Func= \
+                         CV_Func = \
                         CV_DO_PRAGMA(x)= \
                         CV_SUPPRESS_DEPRECATED_START= \
                         CV_SUPPRESS_DEPRECATED_END= \
@@ -1,4 +1,23 @@
 Frequently Asked Questions {#faq}
 ==========================

-Compatibility page. FAQ migrated to the project [wiki](https://github.com/opencv/opencv/wiki/FAQ).
+-   **What is InputArray?**
+
+        It can be seen that almost all OpenCV functions receive InputArray type.
+        What is it, and how can I understand the actual input types of parameters?
+
+
+    This is the proxy class for passing read-only input arrays into OpenCV functions.
+
+    Inside a function you should use cv::_InputArray::getMat() method to construct
+a matrix header for the array (without copying data). cv::_InputArray::kind() can be used to distinguish Mat from vector<> etc.
+but normally it is not needed.
+
+   for more information see cv::_InputArray
+
+-   **Which is more efficient, use contourArea() or count number of ROI non-zero pixels?**
+
+        In a case where you only want relative areas, which one is faster to compute:
+        calculate a contour area or count the number of ROI non-zero pixels?
+
+    cv::contourArea() uses Green formula (http://en.wikipedia.org/wiki/Green's_theorem) to compute the area, therefore its complexity is O(contour_number_of_vertices). Counting non-zero pixels in the ROI is O(roi_width*roi_height) algorithm, i.e. much slower. Note, however, that because of finite, and quite low, resolution of the raster grid, the two algorithms will give noticeably different results. For large and square-like contours the error will be minimal. For small and/or oblong contours the error can be quite large.
@@ -146,7 +146,7 @@ npm install canvas jsdom
@code{.js}
 const { Canvas, createCanvas, Image, ImageData, loadImage } = require('canvas');
 const { JSDOM } = require('jsdom');
-const { writeFileSync, existsSync, mkdirSync } = require("fs");
+const { writeFileSync } = require('fs');

 // This is our program. This time we use JavaScript async / await and promises to handle asynchronicity.
 (async () => {
@@ -1,8 +1,6 @@
 Build OpenCV.js {#tutorial_js_setup}
 ===============================

-@note
-You don't have to build your own copy if you simply want to start using it. Refer the Using Opencv.js tutorial for steps on getting a prebuilt copy from our releases or online documentation.

 Installing Emscripten
 -----------------------------
@@ -4,7 +4,7 @@ Using OpenCV.js {#tutorial_js_usage}
 Steps
 -----

-In this tutorial, you will learn how to include and start to use `opencv.js` inside a web page. You can get a copy of `opencv.js` from `opencv-{VERSION_NUMBER}-docs.zip` in each [release](https://github.com/opencv/opencv/releases), or simply download the prebuilt script from the online documentations at "https://docs.opencv.org/{VERISON_NUMBER}/opencv.js" (For example, [https://docs.opencv.org/3.4.0/opencv.js](https://docs.opencv.org/3.4.0/opencv.js). Use `master` if you want the latest build). You can also build your own copy by following the tutorial on Build Opencv.js.
+In this tutorial, you will learn how to include and start to use `opencv.js` inside a web page.

 ### Create a web page

@@ -44,7 +44,7 @@ To run this web page, copy the content above and save to a local index.html file

 Set the URL of `opencv.js` to `src` attribute of \<script\> tag.

-@note For this tutorial, we host `opencv.js` at same folder as index.html. You can also choose to use the URL of the prebuilt `opencv.js` in our online documentation.
+@note For this tutorial, we host `opencv.js` at same folder as index.html.

 Example for synchronous loading:
@code{.js}
@@ -28,7 +28,7 @@
  #3 & \mbox{#4}\\
  #5 & \mbox{#6}\\
  \end{array} \right.}
-\newcommand{\forkfour}[8]{
+\newcommand{\forkthree}[8]{
  \left\{
  \begin{array}{l l}
  #1 & \mbox{#2}\\
@@ -346,8 +346,7 @@
  year = {2003},
  pages = {363--370},
  publisher = {Springer},
-  url = {https://doi.org/10.1007/3-540-45103-X_50},
-  doi = {10.1007/3-540-45103-X_50}
+  url = {https://arxiv.org/pdf/1808.01752}
 }
@inproceedings{Farsiu03,
  author = {Farsiu, Sina and Robinson, Dirk and Elad, Michael and Milanfar, Peyman},
@@ -621,7 +620,7 @@
  volume = {1},
  publisher = {IEEE}
 }
-@article{Lowe04,
+@article{Lowe:2004:DIF:993451.996342,
  author = {Lowe, David G.},
  title = {Distinctive Image Features from Scale-Invariant Keypoints},
  journal = {Int. J. Comput. Vision},
@@ -16,106 +16,110 @@ python gen_pattern.py -o out.svg -r 11 -c 8 -T circles -s 20.0 -R 5.0 -u mm -w 2
 -H, --help - show help
 """

-import argparse
-
 from svgfig import *

+import sys
+import getopt

 class PatternMaker:
-    def __init__(self, cols, rows, output, units, square_size, radius_rate, page_width, page_height):
-        self.cols = cols
-        self.rows = rows
-        self.output = output
-        self.units = units
-        self.square_size = square_size
-        self.radius_rate = radius_rate
-        self.width = page_width
-        self.height = page_height
-        self.g = SVG("g")  # the svg group container
+  def __init__(self, cols,rows,output,units,square_size,radius_rate,page_width,page_height):
+    self.cols = cols
+    self.rows = rows
+    self.output = output
+    self.units = units
+    self.square_size = square_size
+    self.radius_rate = radius_rate
+    self.width = page_width
+    self.height = page_height
+    self.g = SVG("g") # the svg group container

-    def make_circles_pattern(self):
-        spacing = self.square_size
-        r = spacing / self.radius_rate
-        for x in range(1, self.cols + 1):
-            for y in range(1, self.rows + 1):
-                dot = SVG("circle", cx=x * spacing, cy=y * spacing, r=r, fill="black", stroke="none")
-                self.g.append(dot)
+  def makeCirclesPattern(self):
+    spacing = self.square_size
+    r = spacing / self.radius_rate
+    for x in range(1,self.cols+1):
+      for y in range(1,self.rows+1):
+        dot = SVG("circle", cx=x * spacing, cy=y * spacing, r=r, fill="black", stroke="none")
+        self.g.append(dot)

-    def make_acircles_pattern(self):
-        spacing = self.square_size
-        r = spacing / self.radius_rate
-        for i in range(0, self.rows):
-            for j in range(0, self.cols):
-                dot = SVG("circle", cx=((j * 2 + i % 2) * spacing) + spacing, cy=self.height - (i * spacing + spacing),
-                          r=r, fill="black", stroke="none")
-                self.g.append(dot)
+  def makeACirclesPattern(self):
+    spacing = self.square_size
+    r = spacing / self.radius_rate
+    for i in range(0,self.rows):
+      for j in range(0,self.cols):
+        dot = SVG("circle", cx= ((j*2 + i%2)*spacing) + spacing, cy=self.height - (i * spacing + spacing), r=r, fill="black", stroke="none")
+        self.g.append(dot)

-    def make_checkerboard_pattern(self):
-        spacing = self.square_size
-        xspacing = (self.width - self.cols * self.square_size) / 2.0
-        yspacing = (self.height - self.rows * self.square_size) / 2.0
-        for x in range(0, self.cols):
-            for y in range(0, self.rows):
-                if x % 2 == y % 2:
-                    square = SVG("rect", x=x * spacing + xspacing, y=y * spacing + yspacing, width=spacing,
-                                 height=spacing, fill="black", stroke="none")
-                    self.g.append(square)
+  def makeCheckerboardPattern(self):
+    spacing = self.square_size
+    xspacing = (self.width - self.cols * self.square_size) / 2.0
+    yspacing = (self.height - self.rows * self.square_size) / 2.0
+    for x in range(0,self.cols):
+      for y in range(0,self.rows):
+        if x%2 == y%2:
+          square = SVG("rect", x=x * spacing + xspacing, y=y * spacing + yspacing, width=spacing, height=spacing, fill="black", stroke="none")
+          self.g.append(square)

-    def save(self):
-        c = canvas(self.g, width="%d%s" % (self.width, self.units), height="%d%s" % (self.height, self.units),
-                   viewBox="0 0 %d %d" % (self.width, self.height))
-        c.save(self.output)
+  def save(self):
+    c = canvas(self.g,width="%d%s"%(self.width,self.units),height="%d%s"%(self.height,self.units),viewBox="0 0 %d %d"%(self.width,self.height))
+    c.save(self.output)


 def main():
-    # parse command line options
-    parser = argparse.ArgumentParser(description="generate camera-calibration pattern", add_help=False)
-    parser.add_argument("-H", "--help", help="show help", action="store_true", dest="show_help")
-    parser.add_argument("-o", "--output", help="output file", default="out.svg", action="store", dest="output")
-    parser.add_argument("-c", "--columns", help="pattern columns", default="8", action="store", dest="columns",
-                        type=int)
-    parser.add_argument("-r", "--rows", help="pattern rows", default="11", action="store", dest="rows", type=int)
-    parser.add_argument("-T", "--type", help="type of pattern", default="circles", action="store", dest="p_type",
-                        choices=["circles", "acircles", "checkerboard"])
-    parser.add_argument("-u", "--units", help="length unit", default="mm", action="store", dest="units",
-                        choices=["mm", "inches", "px", "m"])
-    parser.add_argument("-s", "--square_size", help="size of squares in pattern", default="20.0", action="store",
-                        dest="square_size", type=float)
-    parser.add_argument("-R", "--radius_rate", help="circles_radius = square_size/radius_rate", default="5.0",
-                        action="store", dest="radius_rate", type=float)
-    parser.add_argument("-w", "--page_width", help="page width in units", default="216", action="store",
-                        dest="page_width", type=int)
-    parser.add_argument("-h", "--page_height", help="page height in units", default="279", action="store",
-                        dest="page_width", type=int)
-    parser.add_argument("-a", "--page_size", help="page size, supersedes -h -w arguments", default="A4", action="store",
-                        dest="page_size", choices=["A0", "A1", "A2", "A3", "A4", "A5"])
-    args = parser.parse_args()
-
-    show_help = args.show_help
-    if show_help:
-        parser.print_help()
-        return
-    output = args.output
-    columns = args.columns
-    rows = args.rows
-    p_type = args.p_type
-    units = args.units
-    square_size = args.square_size
-    radius_rate = args.radius_rate
-    page_size = args.page_size
+    # parse command line options, TODO use argparse for better doc
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], "Ho:c:r:T:u:s:R:w:h:a:", ["help","output=","columns=","rows=",
+                                                                      "type=","units=","square_size=","radius_rate=",
+                                                                      "page_width=","page_height=", "page_size="])
+    except getopt.error as msg:
+        print(msg)
+        print("for help use --help")
+        sys.exit(2)
+    output = "out.svg"
+    columns = 8
+    rows = 11
+    p_type = "circles"
+    units = "mm"
+    square_size = 20.0
+    radius_rate = 5.0
+    page_size = "A4"
    # page size dict (ISO standard, mm) for easy lookup. format - size: [width, height]
-    page_sizes = {"A0": [840, 1188], "A1": [594, 840], "A2": [420, 594], "A3": [297, 420], "A4": [210, 297],
-                  "A5": [148, 210]}
+    page_sizes = {"A0": [840, 1188], "A1": [594, 840], "A2": [420, 594], "A3": [297, 420], "A4": [210, 297], "A5": [148, 210]}
    page_width = page_sizes[page_size.upper()][0]
    page_height = page_sizes[page_size.upper()][1]
-    pm = PatternMaker(columns, rows, output, units, square_size, radius_rate, page_width, page_height)
-    # dict for easy lookup of pattern type
-    mp = {"circles": pm.make_circles_pattern, "acircles": pm.make_acircles_pattern,
-          "checkerboard": pm.make_checkerboard_pattern}
+    # process options
+    for o, a in opts:
+        if o in ("-H", "--help"):
+            print(__doc__)
+            sys.exit(0)
+        elif o in ("-r", "--rows"):
+            rows = int(a)
+        elif o in ("-c", "--columns"):
+            columns = int(a)
+        elif o in ("-o", "--output"):
+            output = a
+        elif o in ("-T", "--type"):
+            p_type = a
+        elif o in ("-u", "--units"):
+            units = a
+        elif o in ("-s", "--square_size"):
+            square_size = float(a)
+        elif o in ("-R", "--radius_rate"):
+            radius_rate = float(a)
+        elif o in ("-w", "--page_width"):
+            page_width = float(a)
+        elif o in ("-h", "--page_height"):
+            page_height = float(a)
+        elif o in ("-a", "--page_size"):
+            units = "mm"
+            page_size = a.upper()
+            page_width = page_sizes[page_size][0]
+            page_height = page_sizes[page_size][1]
+    pm = PatternMaker(columns,rows,output,units,square_size,radius_rate,page_width,page_height)
+    #dict for easy lookup of pattern type
+    mp = {"circles":pm.makeCirclesPattern,"acircles":pm.makeACirclesPattern,"checkerboard":pm.makeCheckerboardPattern}
    mp[p_type]()
-    # this should save pattern to output
+    #this should save pattern to output
    pm.save()

-
 if __name__ == "__main__":
    main()
@@ -44,7 +44,7 @@ img1 = cv.imread('box.png',0)          # queryImage
 img2 = cv.imread('box_in_scene.png',0) # trainImage

 # Initiate SIFT detector
-sift = cv.SIFT_create()
+sift = cv.xfeatures2d.SIFT_create()

 # find the keypoints and descriptors with SIFT
 kp1, des1 = sift.detectAndCompute(img1,None)
@@ -110,7 +110,7 @@ img1 = cv.imread('box.png',cv.IMREAD_GRAYSCALE)          # queryImage
 img2 = cv.imread('box_in_scene.png',cv.IMREAD_GRAYSCALE) # trainImage

 # Initiate SIFT detector
-sift = cv.SIFT_create()
+sift = cv.xfeatures2d.SIFT_create()

 # find the keypoints and descriptors with SIFT
 kp1, des1 = sift.detectAndCompute(img1,None)
@@ -174,7 +174,7 @@ img1 = cv.imread('box.png',cv.IMREAD_GRAYSCALE)          # queryImage
 img2 = cv.imread('box_in_scene.png',cv.IMREAD_GRAYSCALE) # trainImage

 # Initiate SIFT detector
-sift = cv.SIFT_create()
+sift = cv.xfeatures2d.SIFT_create()

 # find the keypoints and descriptors with SIFT
 kp1, des1 = sift.detectAndCompute(img1,None)
@@ -119,7 +119,7 @@ import cv2 as cv
 img = cv.imread('home.jpg')
 gray= cv.cvtColor(img,cv.COLOR_BGR2GRAY)

-sift = cv.SIFT_create()
+sift = cv.xfeatures2d.SIFT_create()
 kp = sift.detect(gray,None)

 img=cv.drawKeypoints(gray,kp,img)
@@ -151,7 +151,7 @@ Now to calculate the descriptor, OpenCV provides two methods.

 We will see the second method:
@code{.py}
-sift = cv.SIFT_create()
+sift = cv.xfeatures2d.SIFT_create()
 kp, des = sift.detectAndCompute(gray,None)
@endcode
 Here kp will be a list of keypoints and des is a numpy array of shape
@@ -1,4 +1,153 @@
 Getting Started with Images {#tutorial_py_image_display}
 ===========================

-Tutorial content has been moved: @ref tutorial_display_image
+Goals
+-----
+
+-   Here, you will learn how to read an image, how to display it, and how to save it back
+-   You will learn these functions : **cv.imread()**, **cv.imshow()** , **cv.imwrite()**
+-   Optionally, you will learn how to display images with Matplotlib
+
+Using OpenCV
+------------
+
+### Read an image
+
+Use the function **cv.imread()** to read an image. The image should be in the working directory or
+a full path of image should be given.
+
+Second argument is a flag which specifies the way image should be read.
+
+-   cv.IMREAD_COLOR : Loads a color image. Any transparency of image will be neglected. It is the
+    default flag.
+-   cv.IMREAD_GRAYSCALE : Loads image in grayscale mode
+-   cv.IMREAD_UNCHANGED : Loads image as such including alpha channel
+
+@note Instead of these three flags, you can simply pass integers 1, 0 or -1 respectively.
+
+See the code below:
+@code{.py}
+import numpy as np
+import cv2 as cv
+
+# Load a color image in grayscale
+img = cv.imread('messi5.jpg',0)
+@endcode
+
+**warning**
+
+Even if the image path is wrong, it won't throw any error, but `print img` will give you `None`
+
+### Display an image
+
+Use the function **cv.imshow()** to display an image in a window. The window automatically fits to
+the image size.
+
+First argument is a window name which is a string. Second argument is our image. You can create as
+many windows as you wish, but with different window names.
+@code{.py}
+cv.imshow('image',img)
+cv.waitKey(0)
+cv.destroyAllWindows()
+@endcode
+A screenshot of the window will look like this (in Fedora-Gnome machine):
+
+![image](images/opencv_screenshot.jpg)
+
+**cv.waitKey()** is a keyboard binding function. Its argument is the time in milliseconds. The
+function waits for specified milliseconds for any keyboard event. If you press any key in that time,
+the program continues. If **0** is passed, it waits indefinitely for a key stroke. It can also be
+set to detect specific key strokes like, if key a is pressed etc which we will discuss below.
+
+@note Besides binding keyboard events this function also processes many other GUI events, so you
+MUST use it to actually display the image.
+
+**cv.destroyAllWindows()** simply destroys all the windows we created. If you want to destroy any
+specific window, use the function **cv.destroyWindow()** where you pass the exact window name as
+the argument.
+
+@note There is a special case where you can create an empty window and load an image to it later. In
+that case, you can specify whether the window is resizable or not. It is done with the function
+**cv.namedWindow()**. By default, the flag is cv.WINDOW_AUTOSIZE. But if you specify the flag to be
+cv.WINDOW_NORMAL, you can resize window. It will be helpful when an image is too large in dimension
+and when adding track bars to windows.
+
+See the code below:
+@code{.py}
+cv.namedWindow('image', cv.WINDOW_NORMAL)
+cv.imshow('image',img)
+cv.waitKey(0)
+cv.destroyAllWindows()
+@endcode
+### Write an image
+
+Use the function **cv.imwrite()** to save an image.
+
+First argument is the file name, second argument is the image you want to save.
+@code{.py}
+cv.imwrite('messigray.png',img)
+@endcode
+This will save the image in PNG format in the working directory.
+
+### Sum it up
+
+Below program loads an image in grayscale, displays it, saves the image if you press 's' and exit, or
+simply exits without saving if you press ESC key.
+@code{.py}
+import numpy as np
+import cv2 as cv
+
+img = cv.imread('messi5.jpg',0)
+cv.imshow('image',img)
+k = cv.waitKey(0)
+if k == 27:         # wait for ESC key to exit
+    cv.destroyAllWindows()
+elif k == ord('s'): # wait for 's' key to save and exit
+    cv.imwrite('messigray.png',img)
+    cv.destroyAllWindows()
+@endcode
+
+**warning**
+
+If you are using a 64-bit machine, you will have to modify `k = cv.waitKey(0)` line as follows :
+`k = cv.waitKey(0) & 0xFF`
+
+Using Matplotlib
+----------------
+
+Matplotlib is a plotting library for Python which gives you wide variety of plotting methods. You
+will see them in coming articles. Here, you will learn how to display image with Matplotlib. You can
+zoom images, save them, etc, using Matplotlib.
+@code{.py}
+import numpy as np
+import cv2 as cv
+from matplotlib import pyplot as plt
+
+img = cv.imread('messi5.jpg',0)
+plt.imshow(img, cmap = 'gray', interpolation = 'bicubic')
+plt.xticks([]), plt.yticks([])  # to hide tick values on X and Y axis
+plt.show()
+@endcode
+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
+details. Some, we will see on the way.
+
+__warning__
+
+Color image loaded by OpenCV is in BGR mode. But Matplotlib displays in RGB mode. So color images
+will not be displayed correctly in Matplotlib if image is read with OpenCV. Please see the exercises
+for more details.
+
+Additional Resources
+--------------------
+
+-#  [Matplotlib Plotting Styles and Features](http://matplotlib.org/api/pyplot_api.html)
+
+Exercises
+---------
+
+-#  There is some problem when you try to load color image in OpenCV and display it in Matplotlib.
+    Read [this discussion](http://stackoverflow.com/a/15074748/1134940) and understand it.
@@ -1,7 +1,7 @@
 Gui Features in OpenCV {#tutorial_py_table_of_contents_gui}
 ======================

-   @ref tutorial_display_image
+-   @subpage tutorial_py_image_display

    Learn to load an
    image, display it, and save it back
@@ -80,7 +80,7 @@ Probabilistic Hough Transform
 In the hough transform, you can see that even for a line with two arguments, it takes a lot of
 computation. Probabilistic Hough Transform is an optimization of the Hough Transform we saw. It doesn't
 take all the points into consideration. Instead, it takes only a random subset of points which is
-sufficient for line detection. We just have to decrease the threshold. See image below which compares
+sufficient for line detection. Just we have to decrease the threshold. See image below which compares
 Hough Transform and Probabilistic Hough Transform in Hough space. (Image Courtesy :
 [Franck Bettinger's home page](http://phdfb1.free.fr/robot/mscthesis/node14.html) )

@@ -4,20 +4,20 @@ OCR of Hand-written Data using kNN {#tutorial_py_knn_opencv}
 Goal
 ----

-In this chapter:
-    -   We will use our knowledge on kNN to build a basic OCR (Optical Character Recognition) application.
-    -   We will try our application on Digits and Alphabets data that comes with OpenCV.
+In this chapter
+    -   We will use our knowledge on kNN to build a basic OCR application.
+    -   We will try with Digits and Alphabets data available that comes with OpenCV.

 OCR of Hand-written Digits
 --------------------------

-Our goal is to build an application which can read handwritten digits. For this we need some
-training data and some test data. OpenCV comes with an image digits.png (in the folder
+Our goal is to build an application which can read the handwritten digits. For this we need some
+train_data and test_data. OpenCV comes with an image digits.png (in the folder
 opencv/samples/data/) which has 5000 handwritten digits (500 for each digit). Each digit is
-a 20x20 image. So our first step is to split this image into 5000 different digit images. Then for each digit (20x20 image),
-we flatten it into a single row with 400 pixels. That is our feature set, i.e. intensity values of all
-pixels. It is the simplest feature set we can create. We use the first 250 samples of each digit as
-training data, and the other 250 samples as test data. So let's prepare them first.
+a 20x20 image. So our first step is to split this image into 5000 different digits. For each digit,
+we flatten it into a single row with 400 pixels. That is our feature set, ie intensity values of all
+pixels. It is the simplest feature set we can create. We use first 250 samples of each digit as
+train_data, and next 250 samples as test_data. So let's prepare them first.
@code{.py}
 import numpy as np
 import cv2 as cv
@@ -28,10 +28,10 @@ gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
 # Now we split the image to 5000 cells, each 20x20 size
 cells = [np.hsplit(row,100) for row in np.vsplit(gray,50)]

-# Make it into a Numpy array: its size will be (50,100,20,20)
+# Make it into a Numpy array. It size will be (50,100,20,20)
 x = np.array(cells)

-# Now we prepare the training data and test data
+# Now we prepare train_data and test_data.
 train = x[:,:50].reshape(-1,400).astype(np.float32) # Size = (2500,400)
 test = x[:,50:100].reshape(-1,400).astype(np.float32) # Size = (2500,400)

@@ -40,7 +40,7 @@ k = np.arange(10)
 train_labels = np.repeat(k,250)[:,np.newaxis]
 test_labels = train_labels.copy()

-# Initiate kNN, train it on the training data, then test it with the test data with k=1
+# Initiate kNN, train the data, then test it with test data for k=1
 knn = cv.ml.KNearest_create()
 knn.train(train, cv.ml.ROW_SAMPLE, train_labels)
 ret,result,neighbours,dist = knn.findNearest(test,k=5)
@@ -52,15 +52,13 @@ correct = np.count_nonzero(matches)
 accuracy = correct*100.0/result.size
 print( accuracy )
@endcode
-So our basic OCR app is ready. This particular example gave me an accuracy of 91%. One option to
-improve accuracy is to add more data for training, especially for the digits where we had more errors.
-
-Instead of finding
-this training data every time I start the application, I better save it, so that the next time, I can directly
-read this data from a file and start classification. This can be done with the help of some Numpy
-functions like np.savetxt, np.savez, np.load, etc. Please check the NumPy docs for more details.
+So our basic OCR app is ready. This particular example gave me an accuracy of 91%. One option
+improve accuracy is to add more data for training, especially the wrong ones. So instead of finding
+this training data every time I start application, I better save it, so that next time, I directly
+read this data from a file and start classification. You can do it with the help of some Numpy
+functions like np.savetxt, np.savez, np.load etc. Please check their docs for more details.
@code{.py}
-# Save the data
+# save the data
 np.savez('knn_data.npz',train=train, train_labels=train_labels)

 # Now load the data
@@ -73,36 +71,36 @@ In my system, it takes around 4.4 MB of memory. Since we are using intensity val
 features, it would be better to convert the data to np.uint8 first and then save it. It takes only
 1.1 MB in this case. Then while loading, you can convert back into float32.

-OCR of the English Alphabet
+OCR of English Alphabets
 ------------------------

-Next we will do the same for the English alphabet, but there is a slight change in data and feature
+Next we will do the same for English alphabets, but there is a slight change in data and feature
 set. Here, instead of images, OpenCV comes with a data file, letter-recognition.data in
 opencv/samples/cpp/ folder. If you open it, you will see 20000 lines which may, on first sight, look
-like garbage. Actually, in each row, the first column is a letter which is our label. The next 16 numbers
-following it are the different features. These features are obtained from the [UCI Machine Learning
+like garbage. Actually, in each row, first column is an alphabet which is our label. Next 16 numbers
+following it are its different features. These features are obtained from [UCI Machine Learning
 Repository](http://archive.ics.uci.edu/ml/). You can find the details of these features in [this
 page](http://archive.ics.uci.edu/ml/datasets/Letter+Recognition).

-There are 20000 samples available, so we take the first 10000 as training samples and the remaining
-10000 as test samples. We should change the letters to ascii characters because we can't work with
-letters directly.
+There are 20000 samples available, so we take first 10000 data as training samples and remaining
+10000 as test samples. We should change the alphabets to ascii characters because we can't work with
+alphabets directly.
@code{.py}
 import cv2 as cv
 import numpy as np

-# Load the data and convert the letters to numbers
+# Load the data, converters convert the letter to a number
 data= np.loadtxt('letter-recognition.data', dtype= 'float32', delimiter = ',',
                    converters= {0: lambda ch: ord(ch)-ord('A')})

-# Split the dataset in two, with 10000 samples each for training and test sets
+# split the data to two, 10000 each for train and test
 train, test = np.vsplit(data,2)

-# Split trainData and testData into features and responses
+# split trainData and testData to features and responses
 responses, trainData = np.hsplit(train,[1])
 labels, testData = np.hsplit(test,[1])

-# Initiate the kNN, classify, measure accuracy
+# Initiate the kNN, classify, measure accuracy.
 knn = cv.ml.KNearest_create()
 knn.train(trainData, cv.ml.ROW_SAMPLE, responses)
 ret, result, neighbours, dist = knn.findNearest(testData, k=5)
@@ -112,12 +110,10 @@ accuracy = correct*100.0/10000
 print( accuracy )
@endcode
 It gives me an accuracy of 93.22%. Again, if you want to increase accuracy, you can iteratively add
-more data.
+error data in each level.

 Additional Resources
 --------------------
-1. [Wikipedia article on Optical character recognition](https://en.wikipedia.org/wiki/Optical_character_recognition)

 Exercises
 ---------
-1. Here we used k=5. What happens if you try other values of k? Can you find a value that maximizes accuracy (minimizes the number of errors)?
@@ -4,55 +4,61 @@ Understanding k-Nearest Neighbour {#tutorial_py_knn_understanding}
 Goal
 ----

-In this chapter, we will understand the concepts of the k-Nearest Neighbour (kNN) algorithm.
+In this chapter, we will understand the concepts of k-Nearest Neighbour (kNN) algorithm.

 Theory
 ------

-kNN is one of the simplest classification algorithms available for supervised learning. The idea
-is to search for the closest match(es) of the test data in the feature space. We will look into it with the below
+kNN is one of the simplest of classification algorithms available for supervised learning. The idea
+is to search for closest match of the test data in feature space. We will look into it with below
 image.

 ![image](images/knn_theory.png)

-In the image, there are two families: Blue Squares and Red Triangles. We refer to each family as
-a **Class**. Their houses are shown in their town map which we call the **Feature Space**. You can consider
-a feature space as a space where all data are projected. For example, consider a 2D coordinate
-space. Each datum has two features, a x coordinate and a y coordinate. You can represent this datum in your 2D
-coordinate space, right? Now imagine that there are three features, you will need 3D space. Now consider N
-features: you need N-dimensional space, right? This N-dimensional space is its feature space.
-In our image, you can consider it as a 2D case with two features.
+In the image, there are two families, Blue Squares and Red Triangles. We call each family as
+**Class**. Their houses are shown in their town map which we call feature space. *(You can consider
+a feature space as a space where all datas are projected. For example, consider a 2D coordinate
+space. Each data has two features, x and y coordinates. You can represent this data in your 2D
+coordinate space, right? Now imagine if there are three features, you need 3D space. Now consider N
+features, where you need N-dimensional space, right? This N-dimensional space is its feature space.
+In our image, you can consider it as a 2D case with two features)*.

-Now consider what happens if a new member comes into the town and creates a new home, which is shown as the green circle. He
-should be added to one of these Blue or Red families (or *classes*). We call that process, **Classification**. How exactly should this new member be classified? Since we are dealing with kNN, let us apply the algorithm.
+Now a new member comes into the town and creates a new home, which is shown as green circle. He
+should be added to one of these Blue/Red families. We call that process, **Classification**. What we
+do? Since we are dealing with kNN, let us apply this algorithm.

-One simple method is to check who is his nearest neighbour. From the image, it is clear that it is a member of the Red
-Triangle family. So he is classified as a Red Triangle. This method is called simply **Nearest Neighbour** classification, because classification depends only on the *nearest neighbour*.
+One method is to check who is his nearest neighbour. From the image, it is clear it is the Red
+Triangle family. So he is also added into Red Triangle. This method is called simply **Nearest
+Neighbour**, because classification depends only on the nearest neighbour.

-But there is a problem with this approach! Red Triangle may be the nearest neighbour, but what if there are also a lot of Blue
-Squares nearby? Then Blue Squares have more strength in that locality than Red Triangles, so
-just checking the nearest one is not sufficient. Instead we may want to check some **k** nearest families. Then whichever family is the majority amongst them, the new guy should belong to that family. In our image, let's take k=3, i.e. consider the 3 nearest
-neighbours. The new member has two Red neighbours and one Blue neighbour (there are two Blues equidistant, but since k=3, we can take only
+But there is a problem with that. Red Triangle may be the nearest. But what if there are lot of Blue
+Squares near to him? Then Blue Squares have more strength in that locality than Red Triangle. So
+just checking nearest one is not sufficient. Instead we check some k nearest families. Then whoever
+is majority in them, the new guy belongs to that family. In our image, let's take k=3, ie 3 nearest
+families. He has two Red and one Blue (there are two Blues equidistant, but since k=3, we take only
 one of them), so again he should be added to Red family. But what if we take k=7? Then he has 5 Blue
-neighbours and 2 Red neighbours and should be added to the Blue family. The result will vary with the selected
-value of k. Note that if k is not an odd number, we can get a tie, as would happen in the above case with k=4. We would see that our new member has 2 Red and 2 Blue neighbours as his four nearest neighbours and we would need to choose a method for breaking the tie to perform classification. So to reiterate, this method is called **k-Nearest Neighbour** since
-classification depends on the *k nearest neighbours*.
+families and 2 Red families. Great!! Now he should be added to Blue family. So it all changes with
+value of k. More funny thing is, what if k = 4? He has 2 Red and 2 Blue neighbours. It is a tie !!!
+So better take k as an odd number. So this method is called **k-Nearest Neighbour** since
+classification depends on k nearest neighbours.

 Again, in kNN, it is true we are considering k neighbours, but we are giving equal importance to
-all, right? Is this justified? For example, take the tied case of k=4. As we can see, the 2
-Red neighbours are actually closer to the new member than the other 2 Blue neighbours, so he is more eligible to be
-added to the Red family. How do we mathematically explain that? We give some weights to each neighbour
-depending on their distance to the new-comer: those who are nearer to him get higher weights, while
-those that are farther away get lower weights. Then we add the total weights of each family separately and classify the new-comer as part of whichever family
-received higher total weights. This is called **modified kNN** or **weighted kNN**.
+all, right? Is it justice? For example, take the case of k=4. We told it is a tie. But see, the 2
+Red families are more closer to him than the other 2 Blue families. So he is more eligible to be
+added to Red. So how do we mathematically explain that? We give some weights to each family
+depending on their distance to the new-comer. For those who are near to him get higher weights while
+those are far away get lower weights. Then we add total weights of each family separately. Whoever
+gets highest total weights, new-comer goes to that family. This is called **modified kNN**.

 So what are some important things you see here?

-   Because we have to check
-    the distance from the new-comer to all the existing houses to find the nearest neighbour(s), you need to have information about all of the houses in town, right?  If there are plenty of houses and families, it takes a lot of memory, and also more time for calculation.
-   There is almost zero time for any kind of "training" or preparation. Our "learning" involves only memorizing (storing) the data, before testing and classifying.
+-   You need to have information about all the houses in town, right? Because, we have to check
+    the distance from new-comer to all the existing houses to find the nearest neighbour. If there
+    are plenty of houses and families, it takes lots of memory, and more time for calculation
+    also.
+-   There is almost zero time for any kind of training or preparation.

-Now let's see this algorithm at work in OpenCV.
+Now let's see it in OpenCV.

 kNN in OpenCV
 -------------
@@ -61,11 +67,11 @@ We will do a simple example here, with two families (classes), just like above.
 chapter, we will do an even better example.

 So here, we label the Red family as **Class-0** (so denoted by 0) and Blue family as **Class-1**
-(denoted by 1). We create 25 neighbours or 25 training data, and label each of them as either part of Class-0 or Class-1.
-We can do this with the help of a Random Number Generator from NumPy.
+(denoted by 1). We create 25 families or 25 training data, and label them either Class-0 or Class-1.
+We do all these with the help of Random Number Generator in Numpy.

-Then we can plot it with the help of Matplotlib. Red neighbours are shown as Red Triangles and Blue
-neighbours are shown as Blue Squares.
+Then we plot it with the help of Matplotlib. Red families are shown as Red Triangles and Blue
+families are shown as Blue Squares.
@code{.py}
 import cv2 as cv
 import numpy as np
@@ -74,36 +80,36 @@ import matplotlib.pyplot as plt
 # Feature set containing (x,y) values of 25 known/training data
 trainData = np.random.randint(0,100,(25,2)).astype(np.float32)

-# Label each one either Red or Blue with numbers 0 and 1
+# Labels each one either Red or Blue with numbers 0 and 1
 responses = np.random.randint(0,2,(25,1)).astype(np.float32)

-# Take Red neighbours and plot them
+# Take Red families and plot them
 red = trainData[responses.ravel()==0]
 plt.scatter(red[:,0],red[:,1],80,'r','^')

-# Take Blue neighbours and plot them
+# Take Blue families and plot them
 blue = trainData[responses.ravel()==1]
 plt.scatter(blue[:,0],blue[:,1],80,'b','s')

 plt.show()
@endcode
-You will get something similar to our first image. Since you are using a random number generator, you
-will get different data each time you run the code.
+You will get something similar to our first image. Since you are using random number generator, you
+will be getting different data each time you run the code.

-Next initiate the kNN algorithm and pass the trainData and responses to train the kNN. (Underneath the hood, it constructs
-a search tree: see the Additional Resources section below for more information on this.)
+Next initiate the kNN algorithm and pass the trainData and responses to train the kNN (It constructs
+a search tree).

-Then we will bring one new-comer and classify him as belonging to a family with the help of kNN in OpenCV. Before
-running kNN, we need to know something about our test data (data of new comers). Our data should be a
+Then we will bring one new-comer and classify him to a family with the help of kNN in OpenCV. Before
+going to kNN, we need to know something on our test data (data of new comers). Our data should be a
 floating point array with size \f$number \; of \; testdata \times number \; of \; features\f$. Then we
-find the nearest neighbours of the new-comer. We can specify *k*: how many neighbours we want. (Here we used 3.) It returns:
+find the nearest neighbours of new-comer. We can specify how many neighbours we want. It returns:

-1.  The label given to the new-comer depending upon the kNN theory we saw earlier. If you want the *Nearest
-    Neighbour* algorithm, just specify k=1.
-2.  The labels of the k-Nearest Neighbours.
-3.  The corresponding distances from the new-comer to each nearest neighbour.
+-#  The label given to new-comer depending upon the kNN theory we saw earlier. If you want Nearest
+    Neighbour algorithm, just specify k=1 where k is the number of neighbours.
+2.  The labels of k-Nearest Neighbours.
+3.  Corresponding distances from new-comer to each nearest neighbour.

-So let's see how it works. The new-comer is marked in green.
+So let's see how it works. New comer is marked in green color.
@code{.py}
 newcomer = np.random.randint(0,100,(1,2)).astype(np.float32)
 plt.scatter(newcomer[:,0],newcomer[:,1],80,'g','o')
@@ -118,21 +124,21 @@ print( "distance:  {}\n".format(dist) )

 plt.show()
@endcode
-I got the following results:
+I got the result as follows:
@code{.py}
 result:  [[ 1.]]
 neighbours:  [[ 1.  1.  1.]]
 distance:  [[ 53.  58.  61.]]
@endcode
-It says that our new-comer's 3 nearest neighbours are all from the Blue family. Therefore, he is labelled as part of the Blue
-family. It is obvious from the plot below:
+It says our new-comer got 3 neighbours, all from Blue family. Therefore, he is labelled as Blue
+family. It is obvious from plot below:

 ![image](images/knn_simple.png)

-If you have multiple new-comers (test data), you can just pass them as an array. Corresponding results are also
+If you have large number of data, you can just pass it as array. Corresponding results are also
 obtained as arrays.
@code{.py}
-# 10 new-comers
+# 10 new comers
 newcomers = np.random.randint(0,100,(10,2)).astype(np.float32)
 ret, results,neighbours,dist = knn.findNearest(newcomer, 3)
 # The results also will contain 10 labels.
@@ -140,11 +146,8 @@ ret, results,neighbours,dist = knn.findNearest(newcomer, 3)
 Additional Resources
 --------------------

-1.  [NPTEL notes on Pattern Recognition, Chapter
-    11](https://nptel.ac.in/courses/106/108/106108057/)
-2.  [Wikipedia article on Nearest neighbor search](https://en.wikipedia.org/wiki/Nearest_neighbor_search)
-3.  [Wikipedia article on k-d tree](https://en.wikipedia.org/wiki/K-d_tree)
+-#  [NPTEL notes on Pattern Recognition, Chapter
+    11](http://www.nptel.iitm.ac.in/courses/106108057/12)

 Exercises
 ---------
-1. Try repeating the above with more classes and different choices of k. Does choosing k become harder with more classes in the same 2D feature space?
@@ -83,7 +83,7 @@ Let us define a kernel function \f$K(p,q)\f$ which does a dot product between tw
 \begin{aligned}
 K(p,q)  = \phi(p).\phi(q) &= \phi(p)^T \phi(q) \\
                          &= (p_{1}^2,p_{2}^2,\sqrt{2} p_1 p_2).(q_{1}^2,q_{2}^2,\sqrt{2} q_1 q_2) \\
-                          &= p_{1}^2 q_{1}^2 + p_{2}^2 q_{2}^2 + 2 p_1 q_1 p_2 q_2 \\
+                          &= p_1 q_1 + p_2 q_2 + 2 p_1 q_1 p_2 q_2 \\
                          &= (p_1 q_1 + p_2 q_2)^2 \\
          \phi(p).\phi(q) &= (p.q)^2
 \end{aligned}
@@ -80,7 +80,7 @@ Additional Resources
 --------------------

 -#  A Quick guide to Python - [A Byte of Python](http://swaroopch.com/notes/python/)
-2.  [NumPy Quickstart tutorial](https://numpy.org/devdocs/user/quickstart.html)
-3.  [NumPy Reference](https://numpy.org/devdocs/reference/index.html#reference)
+2.  [Basic Numpy Tutorials](http://wiki.scipy.org/Tentative_NumPy_Tutorial)
+3.  [Numpy Examples List](http://wiki.scipy.org/Numpy_Example_List)
 4.  [OpenCV Documentation](http://docs.opencv.org/)
 5.  [OpenCV Forum](http://answers.opencv.org/questions/)
@@ -1,10 +1,6 @@
 Camera calibration With OpenCV {#tutorial_camera_calibration}
 ==============================

-@prev_tutorial{tutorial_camera_calibration_square_chess}
-@next_tutorial{tutorial_real_time_pose}
-
-
 Cameras have been around for a long-long time. However, with the introduction of the cheap *pinhole*
 cameras in the late 20th century, they became a common occurrence in our everyday life.
 Unfortunately, this cheapness comes with its price: significant distortion. Luckily, these are
@@ -1,9 +1,6 @@
 Create calibration pattern {#tutorial_camera_calibration_pattern}
 =========================================

-@next_tutorial{tutorial_camera_calibration_square_chess}
-
-
 The goal of this tutorial is to learn how to create calibration pattern.

 You can find a chessboard pattern in https://github.com/opencv/opencv/blob/master/doc/pattern.png
@@ -1,10 +1,6 @@
 Camera calibration with square chessboard {#tutorial_camera_calibration_square_chess}
 =========================================

-@prev_tutorial{tutorial_camera_calibration_pattern}
-@next_tutorial{tutorial_camera_calibration}
-
-
 The goal of this tutorial is to learn how to calibrate a camera given a set of chessboard images.

 *Test data*: use images in your data/chess folder.
@@ -1,9 +1,6 @@
 Interactive camera calibration application {#tutorial_interactive_calibration}
 ==============================

-@prev_tutorial{tutorial_real_time_pose}
-
-
 According to classical calibration technique user must collect all data first and when run @ref cv::calibrateCamera function
 to obtain camera parameters. If average re-projection error is huge or if estimated parameters seems to be wrong, process of
 selection or collecting data and starting of @ref cv::calibrateCamera repeats.
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Alexander Alekhin	4d34934d25	gapi(simd): initialize accumulator values original commit: `99502e99cc`	2020-03-30 19:36:30 +03:00
Alexander Alekhin	1b5c2bb363	OpenCV version '-openvino'	2020-03-24 16:17:01 +03:00
Alexander Alekhin	45263d7642	dnn: use OpenVINO 2020.2 defines	2020-03-24 16:17:01 +03:00