release: OpenCV 4.0.1 (version++)

Merge tag '4.0.1-openvino'
OpenCV 4.0.1 for Intel(R) OpenVINO(TM) toolkit
2026-07-22 20:03:03 +04:00 · 2018-12-22 07:03:30 +00:00 · 2018-12-22 07:01:13 +00:00 · 2018-12-22 05:40:15 +00:00 · 2018-12-21 13:56:03 +00:00 · 2018-12-19 23:37:55 +03:00
3668 changed files with 165891 additions and 429794 deletions
@@ -1,7 +1,15 @@
 <!--
-If you have a question rather than reporting a bug please go to https://forum.opencv.org where you get much faster responses.
+If you have a question rather than reporting a bug please go to http://answers.opencv.org where you get much faster responses.
 If you need further assistance please read [How To Contribute](https://github.com/opencv/opencv/wiki/How_to_contribute).

+Please:
+
+* Read the documentation to test with the latest developer build.
+* Check if other person has already created the same issue to avoid duplicates. You can comment on it if there already is an issue.
+* Try to be as detailed as possible in your report.
+* Report only one problem per created issue.
+
+
 This is a template helping you to create an issue which can be processed as quickly as possible. This is the bug reporting section for the OpenCV library.
 -->

@@ -1,34 +0,0 @@
-name: PR:3.4
-
-on:
-  pull_request:
-    branches:
-      - 3.4
-
-jobs:
-  Ubuntu2004-ARM64:
-    uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-3.4-ARM64.yaml@main
-
-  Ubuntu1404-x64:
-    uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-3.4-U14.yaml@main
-
-  Ubuntu2004-x64:
-    uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-3.4-U20.yaml@main
-
-  Windows10-x64:
-    uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-3.4-W10.yaml@main
-
-  macOS-ARM64:
-    uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-3.4-macOS-ARM64.yaml@main
-
-  macOS-x64:
-    uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-3.4-macOS-x86_64.yaml@main
-
-  iOS:
-    uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-3.4-iOS.yaml@main
-
-  Android:
-    uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-3.4-Android.yaml@main
-
-  docs:
-    uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-3.4-docs.yaml@main
@@ -22,5 +22,3 @@ bin/
 *.log
 *.tlog
 build
-node_modules
-CMakeSettings.json
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION ${MIN_VER_CMAKE} FATAL_ERROR)
+cmake_minimum_required(VERSION 2.8.11 FATAL_ERROR)

 project(Carotene)

@@ -20,18 +20,11 @@ if(CMAKE_COMPILER_IS_GNUCC)
    # - matchTemplate about 5-10%
    # - goodFeaturesToTrack 10-20%
    # - cornerHarris 30% for some cases
-    if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "10.0.0")
-        set_source_files_properties(${carotene_sources} COMPILE_FLAGS "--param ipcp-unit-growth=100000 --param inline-unit-growth=100000 --param large-stack-frame-growth=5000")
-    else()
-        set_source_files_properties(${carotene_sources} COMPILE_FLAGS "--param ipa-cp-unit-growth=100000 --param inline-unit-growth=100000 --param large-stack-frame-growth=5000")
-    endif()
+
+    set_source_files_properties(${carotene_sources} COMPILE_FLAGS "--param ipcp-unit-growth=100000 --param inline-unit-growth=100000 --param large-stack-frame-growth=5000")
 endif()

-if(APPLE AND CV_CLANG AND WITH_NEON)
-    ocv_warnings_disable(CMAKE_CXX_FLAGS -Wno-unused-function)
-endif()
-
-add_library(carotene_objs OBJECT EXCLUDE_FROM_ALL
+add_library(carotene_objs OBJECT
  ${carotene_headers}
  ${carotene_sources}
 )
@@ -44,5 +37,4 @@ if(WITH_NEON)
    target_compile_definitions(carotene_objs PRIVATE "-DWITH_NEON")
 endif()

-# we add dummy file to fix XCode build
-add_library(carotene STATIC ${OPENCV_3RDPARTY_EXCLUDE_FROM_ALL} "$<TARGET_OBJECTS:carotene_objs>" "${CAROTENE_SOURCE_DIR}/dummy.cpp")
+add_library(carotene STATIC EXCLUDE_FROM_ALL "$<TARGET_OBJECTS:carotene_objs>")
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION ${MIN_VER_CMAKE} FATAL_ERROR)
+cmake_minimum_required(VERSION 2.8.8 FATAL_ERROR)

 include(CheckCCompilerFlag)
 include(CheckCXXCompilerFlag)
@@ -12,6 +12,8 @@ elseif (CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64.*|AARCH64.*")
  set(AARCH64 TRUE)
 endif()

+ocv_warnings_disable(CMAKE_CXX_FLAGS -Wunused-function)
+
 set(TEGRA_COMPILER_FLAGS "")

 if(CV_GCC OR CV_CLANG)
@@ -58,6 +60,22 @@ function(compile_carotene)
  endif()

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

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

-# we add dummy file to fix XCode build
-add_library(tegra_hal STATIC $<TARGET_OBJECTS:carotene_objs> "dummy.cpp")
+add_library(tegra_hal STATIC $<TARGET_OBJECTS:carotene_objs>)
 set_target_properties(tegra_hal PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${3P_LIBRARY_OUTPUT_PATH})
 set(OPENCV_SRC_DIR "${CMAKE_SOURCE_DIR}")
 if(NOT BUILD_SHARED_LIBS)
@@ -1,2 +0,0 @@
-// This file is needed for compilation on some platforms e.g. with XCode generator
-// Related issue: https://gitlab.kitware.com/cmake/cmake/-/issues/17457
@@ -1127,7 +1127,6 @@ inline int TEGRA_FILTERINIT(cvhalFilter2D **context, uchar *kernel_data, size_t
        {
            std::memcpy(ctx->kernel_data + kernel_width * j, kernel_data + kernel_step * j, kernel_width * sizeof(int16_t));
        }
-        break;
    default:
        delete[] ctx->kernel_data;
        delete ctx;
@@ -1244,7 +1243,6 @@ inline int TEGRA_SEPFILTERINIT(cvhalFilter2D **context, int src_type, int dst_ty
        ctx->kernely_data[0]=((int16_t*)kernely_data)[0];
        ctx->kernely_data[1]=((int16_t*)kernely_data)[1];
        ctx->kernely_data[2]=((int16_t*)kernely_data)[2];
-        break;
    default:
        delete ctx;
        return CV_HAL_ERROR_NOT_IMPLEMENTED;
@@ -1296,13 +1294,13 @@ struct MorphCtx
    CAROTENE_NS::BORDER_MODE border;
    uchar borderValues[4];
 };
-inline int TEGRA_MORPHINIT(cvhalFilter2D **context, int operation, int src_type, int dst_type, int width, int height,
+inline int TEGRA_MORPHINIT(cvhalFilter2D **context, int operation, int src_type, int dst_type, int, int,
                           int kernel_type, uchar *kernel_data, size_t kernel_step, int kernel_width, int kernel_height, int anchor_x, int anchor_y,
                           int borderType, const double borderValue[4], int iterations, bool allowSubmatrix, bool allowInplace)
 {
    if(!context || !kernel_data || src_type != dst_type ||
       CV_MAT_DEPTH(src_type) != CV_8U || src_type < 0 || (src_type >> CV_CN_SHIFT) > 3 ||
-       width < kernel_width || height < kernel_height ||
+
       allowSubmatrix || allowInplace || iterations != 1 ||
       !CAROTENE_NS::isSupportedConfiguration())
        return CV_HAL_ERROR_NOT_IMPLEMENTED;
@@ -1778,30 +1776,30 @@ TegraCvtColor_Invoker(bgrx2hsvf, bgrx2hsv, src_data + static_cast<size_t>(range.
    : CV_HAL_ERROR_NOT_IMPLEMENTED \
 )

-#define TEGRA_CVT2PYUVTOBGR_EX(y_data, y_step, uv_data, uv_step, dst_data, dst_step, dst_width, dst_height, dcn, swapBlue, uIdx) \
+#define TEGRA_CVT2PYUVTOBGR(src_data, src_step, dst_data, dst_step, dst_width, dst_height, dcn, swapBlue, uIdx) \
 ( \
    CAROTENE_NS::isSupportedConfiguration() ? \
        dcn == 3 ? \
            uIdx == 0 ? \
                (swapBlue ? \
                    CAROTENE_NS::yuv420i2rgb(CAROTENE_NS::Size2D(dst_width, dst_height), \
-                                             y_data, y_step, \
-                                             uv_data, uv_step, \
+                                             src_data, src_step, \
+                                             src_data + src_step * dst_height, src_step, \
                                             dst_data, dst_step) : \
                    CAROTENE_NS::yuv420i2bgr(CAROTENE_NS::Size2D(dst_width, dst_height), \
-                                             y_data, y_step, \
-                                             uv_data, uv_step, \
+                                             src_data, src_step, \
+                                             src_data + src_step * dst_height, src_step, \
                                             dst_data, dst_step)), \
                CV_HAL_ERROR_OK : \
            uIdx == 1 ? \
                (swapBlue ? \
                    CAROTENE_NS::yuv420sp2rgb(CAROTENE_NS::Size2D(dst_width, dst_height), \
-                                              y_data, y_step, \
-                                              uv_data, uv_step, \
+                                              src_data, src_step, \
+                                              src_data + src_step * dst_height, src_step, \
                                              dst_data, dst_step) : \
                    CAROTENE_NS::yuv420sp2bgr(CAROTENE_NS::Size2D(dst_width, dst_height), \
-                                              y_data, y_step, \
-                                              uv_data, uv_step, \
+                                              src_data, src_step, \
+                                              src_data + src_step * dst_height, src_step, \
                                              dst_data, dst_step)), \
                CV_HAL_ERROR_OK : \
            CV_HAL_ERROR_NOT_IMPLEMENTED : \
@@ -1809,32 +1807,29 @@ TegraCvtColor_Invoker(bgrx2hsvf, bgrx2hsv, src_data + static_cast<size_t>(range.
            uIdx == 0 ? \
                (swapBlue ? \
                    CAROTENE_NS::yuv420i2rgbx(CAROTENE_NS::Size2D(dst_width, dst_height), \
-                                              y_data, y_step, \
-                                              uv_data, uv_step, \
+                                              src_data, src_step, \
+                                              src_data + src_step * dst_height, src_step, \
                                              dst_data, dst_step) : \
                    CAROTENE_NS::yuv420i2bgrx(CAROTENE_NS::Size2D(dst_width, dst_height), \
-                                              y_data, y_step, \
-                                              uv_data, uv_step, \
+                                              src_data, src_step, \
+                                              src_data + src_step * dst_height, src_step, \
                                              dst_data, dst_step)), \
                CV_HAL_ERROR_OK : \
            uIdx == 1 ? \
                (swapBlue ? \
                    CAROTENE_NS::yuv420sp2rgbx(CAROTENE_NS::Size2D(dst_width, dst_height), \
-                                               y_data, y_step, \
-                                               uv_data, uv_step, \
+                                               src_data, src_step, \
+                                               src_data + src_step * dst_height, src_step, \
                                               dst_data, dst_step) : \
                    CAROTENE_NS::yuv420sp2bgrx(CAROTENE_NS::Size2D(dst_width, dst_height), \
-                                               y_data, y_step, \
-                                               uv_data, uv_step, \
+                                               src_data, src_step, \
+                                               src_data + src_step * dst_height, src_step, \
                                               dst_data, dst_step)), \
                CV_HAL_ERROR_OK : \
            CV_HAL_ERROR_NOT_IMPLEMENTED : \
        CV_HAL_ERROR_NOT_IMPLEMENTED \
    : CV_HAL_ERROR_NOT_IMPLEMENTED \
 )
-#define TEGRA_CVT2PYUVTOBGR(src_data, src_step, dst_data, dst_step, dst_width, dst_height, dcn, swapBlue, uIdx) \
-    TEGRA_CVT2PYUVTOBGR_EX(src_data, src_step, src_data + src_step * dst_height, src_step, dst_data, dst_step, \
-            dst_width, dst_height, dcn, swapBlue, uIdx);

 #undef cv_hal_cvtBGRtoBGR
 #define cv_hal_cvtBGRtoBGR TEGRA_CVTBGRTOBGR
@@ -1844,18 +1839,12 @@ TegraCvtColor_Invoker(bgrx2hsvf, bgrx2hsv, src_data + static_cast<size_t>(range.
 #define cv_hal_cvtBGRtoGray TEGRA_CVTBGRTOGRAY
 #undef cv_hal_cvtGraytoBGR
 #define cv_hal_cvtGraytoBGR TEGRA_CVTGRAYTOBGR
-#if 0  // bit-exact tests are failed
 #undef cv_hal_cvtBGRtoYUV
 #define cv_hal_cvtBGRtoYUV TEGRA_CVTBGRTOYUV
-#endif
 #undef cv_hal_cvtBGRtoHSV
 #define cv_hal_cvtBGRtoHSV TEGRA_CVTBGRTOHSV
-#if 0  // bit-exact tests are failed
 #undef cv_hal_cvtTwoPlaneYUVtoBGR
 #define cv_hal_cvtTwoPlaneYUVtoBGR TEGRA_CVT2PYUVTOBGR
-#undef cv_hal_cvtTwoPlaneYUVtoBGREx
-#define cv_hal_cvtTwoPlaneYUVtoBGREx TEGRA_CVT2PYUVTOBGR_EX
-#endif

 #endif // OPENCV_IMGPROC_HAL_INTERFACE_H

@@ -109,9 +109,9 @@ template <> struct wAdd<s32>
        vgamma = vdupq_n_f32(_gamma + 0.5);
    }

-    void operator() (const VecTraits<s32>::vec128 & v_src0,
-                     const VecTraits<s32>::vec128 & v_src1,
-                     VecTraits<s32>::vec128 & v_dst) const
+    void operator() (const typename VecTraits<s32>::vec128 & v_src0,
+                     const typename VecTraits<s32>::vec128 & v_src1,
+                     typename VecTraits<s32>::vec128 & v_dst) const
    {
        float32x4_t vs1 = vcvtq_f32_s32(v_src0);
        float32x4_t vs2 = vcvtq_f32_s32(v_src1);
@@ -121,9 +121,9 @@ template <> struct wAdd<s32>
        v_dst = vcvtq_s32_f32(vs1);
    }

-    void operator() (const VecTraits<s32>::vec64 & v_src0,
-                     const VecTraits<s32>::vec64 & v_src1,
-                     VecTraits<s32>::vec64 & v_dst) const
+    void operator() (const typename VecTraits<s32>::vec64 & v_src0,
+                     const typename VecTraits<s32>::vec64 & v_src1,
+                     typename VecTraits<s32>::vec64 & v_dst) const
    {
        float32x2_t vs1 = vcvt_f32_s32(v_src0);
        float32x2_t vs2 = vcvt_f32_s32(v_src1);
@@ -153,9 +153,9 @@ template <> struct wAdd<u32>
        vgamma = vdupq_n_f32(_gamma + 0.5);
    }

-    void operator() (const VecTraits<u32>::vec128 & v_src0,
-                     const VecTraits<u32>::vec128 & v_src1,
-                     VecTraits<u32>::vec128 & v_dst) const
+    void operator() (const typename VecTraits<u32>::vec128 & v_src0,
+                     const typename VecTraits<u32>::vec128 & v_src1,
+                     typename VecTraits<u32>::vec128 & v_dst) const
    {
        float32x4_t vs1 = vcvtq_f32_u32(v_src0);
        float32x4_t vs2 = vcvtq_f32_u32(v_src1);
@@ -165,9 +165,9 @@ template <> struct wAdd<u32>
        v_dst = vcvtq_u32_f32(vs1);
    }

-    void operator() (const VecTraits<u32>::vec64 & v_src0,
-                     const VecTraits<u32>::vec64 & v_src1,
-                     VecTraits<u32>::vec64 & v_dst) const
+    void operator() (const typename VecTraits<u32>::vec64 & v_src0,
+                     const typename VecTraits<u32>::vec64 & v_src1,
+                     typename VecTraits<u32>::vec64 & v_dst) const
    {
        float32x2_t vs1 = vcvt_f32_u32(v_src0);
        float32x2_t vs2 = vcvt_f32_u32(v_src1);
@@ -197,17 +197,17 @@ template <> struct wAdd<f32>
        vgamma = vdupq_n_f32(_gamma + 0.5);
    }

-    void operator() (const VecTraits<f32>::vec128 & v_src0,
-                     const VecTraits<f32>::vec128 & v_src1,
-                     VecTraits<f32>::vec128 & v_dst) const
+    void operator() (const typename VecTraits<f32>::vec128 & v_src0,
+                     const typename VecTraits<f32>::vec128 & v_src1,
+                     typename VecTraits<f32>::vec128 & v_dst) const
    {
        float32x4_t vs1 = vmlaq_f32(vgamma, v_src0, valpha);
        v_dst = vmlaq_f32(vs1, v_src1, vbeta);
    }

-    void operator() (const VecTraits<f32>::vec64 & v_src0,
-                     const VecTraits<f32>::vec64 & v_src1,
-                     VecTraits<f32>::vec64 & v_dst) const
+    void operator() (const typename VecTraits<f32>::vec64 & v_src0,
+                     const typename VecTraits<f32>::vec64 & v_src1,
+                     typename VecTraits<f32>::vec64 & v_dst) const
    {
        float32x2_t vs1 = vmla_f32(vget_low(vgamma), v_src0, vget_low(valpha));
        v_dst = vmla_f32(vs1, v_src1, vget_low(vbeta));
@@ -49,12 +49,12 @@ namespace {

 enum
 {
-    SHIFT = 14,
+    SHIFT = 15,
    SHIFT_DELTA = 1 << (SHIFT - 1),

-    R2Y_BT601   = 4899,
-    G2Y_BT601   = 9617,
-    B2Y_BT601   = 1868,
+    R2Y_BT601   = 9798,
+    G2Y_BT601   = 19235,
+    B2Y_BT601   = 3735,

    R2Y_BT709   = 3483,
    G2Y_BT709   = 11718,
@@ -151,6 +151,10 @@ void div(const Size2D &size,
    typedef typename internal::VecTraits<T>::vec128 vec128;
    typedef typename internal::VecTraits<T>::vec64 vec64;

+#if defined(__GNUC__) && (defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L)
+    static_assert(std::numeric_limits<T>::is_integer, "template implementation is for integer types only");
+#endif
+
    if (scale == 0.0f ||
        (std::numeric_limits<T>::is_integer &&
         (scale * std::numeric_limits<T>::max()) <  1.0f &&
@@ -311,6 +315,10 @@ void recip(const Size2D &size,
    typedef typename internal::VecTraits<T>::vec128 vec128;
    typedef typename internal::VecTraits<T>::vec64 vec64;

+#if defined(__GNUC__) && (defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L)
+    static_assert(std::numeric_limits<T>::is_integer, "template implementation is for integer types only");
+#endif
+
    if (scale == 0.0f ||
        (std::numeric_limits<T>::is_integer &&
         scale <  1.0f &&
@@ -463,8 +471,6 @@ void div(const Size2D &size,
        return;
    }

-    float32x4_t v_zero = vdupq_n_f32(0.0f);
-
    size_t roiw128 = size.width >= 3 ? size.width - 3 : 0;
    size_t roiw64 = size.width >= 1 ? size.width - 1 : 0;

@@ -485,9 +491,7 @@ void div(const Size2D &size,
                float32x4_t v_src0 = vld1q_f32(src0 + j);
                float32x4_t v_src1 = vld1q_f32(src1 + j);

-                uint32x4_t v_mask = vceqq_f32(v_src1,v_zero);
-                vst1q_f32(dst + j, vreinterpretq_f32_u32(vbicq_u32(
-                                   vreinterpretq_u32_f32(vmulq_f32(v_src0, internal::vrecpq_f32(v_src1))), v_mask)));
+                vst1q_f32(dst + j, vmulq_f32(v_src0, internal::vrecpq_f32(v_src1)));
            }

            for (; j < roiw64; j += 2)
@@ -495,14 +499,12 @@ void div(const Size2D &size,
                float32x2_t v_src0 = vld1_f32(src0 + j);
                float32x2_t v_src1 = vld1_f32(src1 + j);

-                uint32x2_t v_mask = vceq_f32(v_src1,vget_low_f32(v_zero));
-                vst1_f32(dst + j, vreinterpret_f32_u32(vbic_u32(
-                                  vreinterpret_u32_f32(vmul_f32(v_src0, internal::vrecp_f32(v_src1))), v_mask)));
+                vst1_f32(dst + j, vmul_f32(v_src0, internal::vrecp_f32(v_src1)));
            }

            for (; j < size.width; j++)
            {
-                dst[j] = src1[j] ? src0[j] / src1[j] : 0.0f;
+                dst[j] = src0[j] / src1[j];
            }
        }
    }
@@ -523,10 +525,8 @@ void div(const Size2D &size,
                float32x4_t v_src0 = vld1q_f32(src0 + j);
                float32x4_t v_src1 = vld1q_f32(src1 + j);

-                uint32x4_t v_mask = vceqq_f32(v_src1,v_zero);
-                vst1q_f32(dst + j, vreinterpretq_f32_u32(vbicq_u32(
-                                   vreinterpretq_u32_f32(vmulq_f32(vmulq_n_f32(v_src0, scale),
-                                                         internal::vrecpq_f32(v_src1))), v_mask)));
+                vst1q_f32(dst + j, vmulq_f32(vmulq_n_f32(v_src0, scale),
+                                             internal::vrecpq_f32(v_src1)));
            }

            for (; j < roiw64; j += 2)
@@ -534,15 +534,13 @@ void div(const Size2D &size,
                float32x2_t v_src0 = vld1_f32(src0 + j);
                float32x2_t v_src1 = vld1_f32(src1 + j);

-                uint32x2_t v_mask = vceq_f32(v_src1,vget_low_f32(v_zero));
-                vst1_f32(dst + j, vreinterpret_f32_u32(vbic_u32(
-                                  vreinterpret_u32_f32(vmul_f32(vmul_n_f32(v_src0, scale),
-                                                                internal::vrecp_f32(v_src1))), v_mask)));
+                vst1_f32(dst + j, vmul_f32(vmul_n_f32(v_src0, scale),
+                                           internal::vrecp_f32(v_src1)));
            }

            for (; j < size.width; j++)
            {
-                dst[j] = src1[j] ? src0[j] * scale / src1[j] : 0.0f;
+                dst[j] = src0[j] * scale / src1[j];
            }
        }
    }
@@ -620,8 +618,6 @@ void reciprocal(const Size2D &size,
        return;
    }

-    float32x4_t v_zero = vdupq_n_f32(0.0f);
-
    size_t roiw128 = size.width >= 3 ? size.width - 3 : 0;
    size_t roiw64 = size.width >= 1 ? size.width - 1 : 0;

@@ -639,23 +635,19 @@ void reciprocal(const Size2D &size,

                float32x4_t v_src1 = vld1q_f32(src1 + j);

-                uint32x4_t v_mask = vceqq_f32(v_src1,v_zero);
-                vst1q_f32(dst + j, vreinterpretq_f32_u32(vbicq_u32(
-                                   vreinterpretq_u32_f32(internal::vrecpq_f32(v_src1)), v_mask)));
+                vst1q_f32(dst + j, internal::vrecpq_f32(v_src1));
            }

            for (; j < roiw64; j += 2)
            {
                float32x2_t v_src1 = vld1_f32(src1 + j);

-                uint32x2_t v_mask = vceq_f32(v_src1,vget_low_f32(v_zero));
-                vst1_f32(dst + j, vreinterpret_f32_u32(vbic_u32(
-                                  vreinterpret_u32_f32(internal::vrecp_f32(v_src1)), v_mask)));
+                vst1_f32(dst + j, internal::vrecp_f32(v_src1));
            }

            for (; j < size.width; j++)
            {
-                dst[j] = src1[j] ? 1.0f / src1[j] : 0;
+                dst[j] = 1.0f / src1[j];
            }
        }
    }
@@ -673,25 +665,19 @@ void reciprocal(const Size2D &size,

                float32x4_t v_src1 = vld1q_f32(src1 + j);

-                uint32x4_t v_mask = vceqq_f32(v_src1,v_zero);
-                vst1q_f32(dst + j, vreinterpretq_f32_u32(vbicq_u32(
-                                   vreinterpretq_u32_f32(vmulq_n_f32(internal::vrecpq_f32(v_src1),
-                                                                     scale)),v_mask)));
+                vst1q_f32(dst + j, vmulq_n_f32(internal::vrecpq_f32(v_src1), scale));
            }

            for (; j < roiw64; j += 2)
            {
                float32x2_t v_src1 = vld1_f32(src1 + j);

-                uint32x2_t v_mask = vceq_f32(v_src1,vget_low_f32(v_zero));
-                vst1_f32(dst + j, vreinterpret_f32_u32(vbic_u32(
-                                  vreinterpret_u32_f32(vmul_n_f32(internal::vrecp_f32(v_src1),
-                                                                  scale)), v_mask)));
+                vst1_f32(dst + j, vmul_n_f32(internal::vrecp_f32(v_src1), scale));
            }

            for (; j < size.width; j++)
            {
-                dst[j] = src1[j] ? scale / src1[j] : 0;
+                dst[j] = scale / src1[j];
            }
        }
    }
@@ -1,2 +0,0 @@
-// This file is needed for compilation on some platforms e.g. with XCode generator
-// Related issue: https://gitlab.kitware.com/cmake/cmake/-/issues/17457
@@ -109,7 +109,6 @@ bool isResizeLinearOpenCVSupported(const Size2D &ssize, const Size2D &dsize, u32
            && dsize.width >= 2 && dsize.height >= 8
            && (2*dsize.width != ssize.width || 2*dsize.height != ssize.height)) // 2x downscaling is performed as area in OpenCV which differs from this implementation
            return isSupportedConfiguration();
-        return false;
    default:
        return false;
    };
@@ -758,7 +757,7 @@ inline void resizeAreaRounding(const Size2D &ssize, const Size2D &dsize,
    }
    else if (channels == 3)
    {
-        if ((wr == 2.0f) && (hr == 2.0f))
+        if ((wr == 2.0f) && (wr == 2.0f))
        {
 #ifndef __ANDROID__
            size_t roiw16 = dsize.width >= 15 ? (dsize.width - 15) * 3 : 0;
@@ -14,7 +14,7 @@ if(NOT DEFINED CPUFEATURES_SOURCES)
 endif()

 include_directories(${CPUFEATURES_INCLUDE_DIRS})
-add_library(${OPENCV_CPUFEATURES_TARGET_NAME} STATIC ${OPENCV_3RDPARTY_EXCLUDE_FROM_ALL} ${CPUFEATURES_SOURCES})
+add_library(${OPENCV_CPUFEATURES_TARGET_NAME} STATIC ${CPUFEATURES_SOURCES})

 set_target_properties(${OPENCV_CPUFEATURES_TARGET_NAME}
  PROPERTIES OUTPUT_NAME cpufeatures
@@ -29,7 +29,7 @@ if(ENABLE_SOLUTION_FOLDERS)
 endif()

 if(NOT BUILD_SHARED_LIBS)
-  ocv_install_target(${OPENCV_CPUFEATURES_TARGET_NAME} EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev OPTIONAL)
+  ocv_install_target(${OPENCV_CPUFEATURES_TARGET_NAME} EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev)
 endif()

 ocv_install_3rdparty_licenses(cpufeatures LICENSE README.md)
@@ -30,6 +30,7 @@

 #include <sys/cdefs.h>
 #include <stdint.h>
+#include <string.h>

 __BEGIN_DECLS

@@ -12,22 +12,6 @@ Write-Output ("=" * 120)
 Write-Output ""

 if(![System.IO.File]::Exists($output)) {
-    try {
-        [io.file]::OpenWrite($output).close()
-    } catch {
-        Write-Warning "Unable to write: $output"
-        if (!([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole] "Administrator")) {
-            Write-Warning "Launching with 'Administrator' elevated privileges..."
-            Pause
-            Start-Process powershell.exe "-NoProfile -ExecutionPolicy Bypass -File `"$PSCommandPath`"" -Verb RunAs
-            exit
-        } else {
-            Write-Output "FATAL: Unable to write with elevated privileges: $output"
-            Pause
-            exit 1
-        }
-    }
-
    try {
        Write-Output ("Downloading: " + $output)
        Import-Module BitsTransfer
@@ -1,9 +1,9 @@
-# Binaries branch name: 3.4_20230620
-# Binaries were created for OpenCV: c97c22b7cf2ef0f82cd4203a2e9a6eda94e9f7f1
-ocv_update(FFMPEG_BINARIES_COMMIT "7c4bb90fd43a13732ae907981a88fb983a7e2197")
-ocv_update(FFMPEG_FILE_HASH_BIN32 "d7db86de29b0460294489c5ed3180b56")
-ocv_update(FFMPEG_FILE_HASH_BIN64 "9df93d8afff2eee368ad484098a12b18")
-ocv_update(FFMPEG_FILE_HASH_CMAKE "3b90f67f4b429e77d3da36698cef700c")
+# Binaries branch name: ffmpeg/master_20181106
+# Binaries were created for OpenCV: 2c6f1ab57d4250ee46e32d1b51c056431965b470
+ocv_update(FFMPEG_BINARIES_COMMIT "759a23e24ab787a0979f8a93103dcc3105ec10c1")
+ocv_update(FFMPEG_FILE_HASH_BIN32 "849286ccc527c99e5a218b67f13c6e8c")
+ocv_update(FFMPEG_FILE_HASH_BIN64 "96444a4645753aaafa296479665c9185")
+ocv_update(FFMPEG_FILE_HASH_CMAKE "f710891525a04586d565d0e700e62a9c")

 function(download_win_ffmpeg script_var)
  set(${script_var} "" PARENT_SCOPE)
@@ -1,122 +0,0 @@
-/**********************************************************************************
- * Copyright (c) 2008-2009 The Khronos Group Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and/or associated documentation files (the
- * "Materials"), to deal in the Materials without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Materials, and to
- * permit persons to whom the Materials are furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Materials.
- *
- * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
- **********************************************************************************/
-
-#ifndef __OPENCL_CL_D3D11_EXT_H
-#define __OPENCL_CL_D3D11_EXT_H
-
-#include <d3d11.h>
-#include <CL/cl.h>
-#include <CL/cl_platform.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/******************************************************************************
- * cl_nv_d3d11_sharing                                                        */
-
-typedef cl_uint cl_d3d11_device_source_nv;
-typedef cl_uint cl_d3d11_device_set_nv;
-
-/******************************************************************************/
-
-// Error Codes
-#define CL_INVALID_D3D11_DEVICE_NV             -1006
-#define CL_INVALID_D3D11_RESOURCE_NV           -1007
-#define CL_D3D11_RESOURCE_ALREADY_ACQUIRED_NV  -1008
-#define CL_D3D11_RESOURCE_NOT_ACQUIRED_NV      -1009
-
-// cl_d3d11_device_source_nv
-#define CL_D3D11_DEVICE_NV                     0x4019
-#define CL_D3D11_DXGI_ADAPTER_NV               0x401A
-
-// cl_d3d11_device_set_nv
-#define CL_PREFERRED_DEVICES_FOR_D3D11_NV      0x401B
-#define CL_ALL_DEVICES_FOR_D3D11_NV            0x401C
-
-// cl_context_info
-#define CL_CONTEXT_D3D11_DEVICE_NV             0x401D
-
-// cl_mem_info
-#define CL_MEM_D3D11_RESOURCE_NV               0x401E
-
-// cl_image_info
-#define CL_IMAGE_D3D11_SUBRESOURCE_NV          0x401F
-
-// cl_command_type
-#define CL_COMMAND_ACQUIRE_D3D11_OBJECTS_NV    0x4020
-#define CL_COMMAND_RELEASE_D3D11_OBJECTS_NV    0x4021
-
-/******************************************************************************/
-
-typedef CL_API_ENTRY cl_int (CL_API_CALL *clGetDeviceIDsFromD3D11NV_fn)(
-    cl_platform_id            platform,
-    cl_d3d11_device_source_nv d3d_device_source,
-    void *                    d3d_object,
-    cl_d3d11_device_set_nv    d3d_device_set,
-    cl_uint                   num_entries, 
-    cl_device_id *            devices, 
-    cl_uint *                 num_devices) CL_API_SUFFIX__VERSION_1_0;
-
-typedef CL_API_ENTRY cl_mem (CL_API_CALL *clCreateFromD3D11BufferNV_fn)(
-    cl_context     context,
-    cl_mem_flags   flags,
-    ID3D11Buffer * resource,
-    cl_int *       errcode_ret) CL_API_SUFFIX__VERSION_1_0;
-
-typedef CL_API_ENTRY cl_mem (CL_API_CALL *clCreateFromD3D11Texture2DNV_fn)(
-    cl_context        context,
-    cl_mem_flags      flags,
-    ID3D11Texture2D * resource,
-    UINT              subresource,
-    cl_int *          errcode_ret) CL_API_SUFFIX__VERSION_1_0;
-
-typedef CL_API_ENTRY cl_mem (CL_API_CALL *clCreateFromD3D11Texture3DNV_fn)(
-    cl_context        context,
-    cl_mem_flags      flags,
-    ID3D11Texture3D * resource,
-    UINT              subresource,
-    cl_int *          errcode_ret) CL_API_SUFFIX__VERSION_1_0;
-
-typedef CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueAcquireD3D11ObjectsNV_fn)(
-    cl_command_queue command_queue,
-    cl_uint          num_objects,
-    const cl_mem *   mem_objects,
-    cl_uint          num_events_in_wait_list,
-    const cl_event * event_wait_list,
-    cl_event *       event) CL_API_SUFFIX__VERSION_1_0;
-
-typedef CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueReleaseD3D11ObjectsNV_fn)(
-    cl_command_queue command_queue,
-    cl_uint          num_objects,
-    cl_mem *         mem_objects,
-    cl_uint          num_events_in_wait_list,
-    const cl_event * event_wait_list,
-    cl_event *       event) CL_API_SUFFIX__VERSION_1_0;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // __OPENCL_CL_D3D11_H
-
@@ -0,0 +1,92 @@
+//
+// File: vk_platform.h
+//
+/*
+** Copyright (c) 2014-2017 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+
+#ifndef VK_PLATFORM_H_
+#define VK_PLATFORM_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif // __cplusplus
+
+/*
+***************************************************************************************************
+*   Platform-specific directives and type declarations
+***************************************************************************************************
+*/
+
+/* Platform-specific calling convention macros.
+ *
+ * Platforms should define these so that Vulkan clients call Vulkan commands
+ * with the same calling conventions that the Vulkan implementation expects.
+ *
+ * VKAPI_ATTR - Placed before the return type in function declarations.
+ *              Useful for C++11 and GCC/Clang-style function attribute syntax.
+ * VKAPI_CALL - Placed after the return type in function declarations.
+ *              Useful for MSVC-style calling convention syntax.
+ * VKAPI_PTR  - Placed between the '(' and '*' in function pointer types.
+ *
+ * Function declaration:  VKAPI_ATTR void VKAPI_CALL vkCommand(void);
+ * Function pointer type: typedef void (VKAPI_PTR *PFN_vkCommand)(void);
+ */
+#if defined(_WIN32)
+    // On Windows, Vulkan commands use the stdcall convention
+    #define VKAPI_ATTR
+    #define VKAPI_CALL __stdcall
+    #define VKAPI_PTR  VKAPI_CALL
+#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7
+    #error "Vulkan isn't supported for the 'armeabi' NDK ABI"
+#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && defined(__ARM_32BIT_STATE)
+    // On Android 32-bit ARM targets, Vulkan functions use the "hardfloat"
+    // calling convention, i.e. float parameters are passed in registers. This
+    // is true even if the rest of the application passes floats on the stack,
+    // as it does by default when compiling for the armeabi-v7a NDK ABI.
+    #define VKAPI_ATTR __attribute__((pcs("aapcs-vfp")))
+    #define VKAPI_CALL
+    #define VKAPI_PTR  VKAPI_ATTR
+#else
+    // On other platforms, use the default calling convention
+    #define VKAPI_ATTR
+    #define VKAPI_CALL
+    #define VKAPI_PTR
+#endif
+
+#include <stddef.h>
+
+#if !defined(VK_NO_STDINT_H)
+    #if defined(_MSC_VER) && (_MSC_VER < 1600)
+        typedef signed   __int8  int8_t;
+        typedef unsigned __int8  uint8_t;
+        typedef signed   __int16 int16_t;
+        typedef unsigned __int16 uint16_t;
+        typedef signed   __int32 int32_t;
+        typedef unsigned __int32 uint32_t;
+        typedef signed   __int64 int64_t;
+        typedef unsigned __int64 uint64_t;
+    #else
+        #include <stdint.h>
+    #endif
+#endif // !defined(VK_NO_STDINT_H)
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus
+
+#endif
@@ -0,0 +1,83 @@
+#ifndef VULKAN_H_
+#define VULKAN_H_ 1
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#include "vk_platform.h"
+#include "vulkan_core.h"
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+#include "vulkan_android.h"
+#endif
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+#include <zircon/types.h>
+#include "vulkan_fuchsia.h"
+#endif
+
+#ifdef VK_USE_PLATFORM_IOS_MVK
+#include "vulkan_ios.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+#include "vulkan_macos.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_MIR_KHR
+#include <mir_toolkit/client_types.h>
+#include "vulkan_mir.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_VI_NN
+#include "vulkan_vi.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+#include <wayland-client.h>
+#include "vulkan_wayland.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+#include <windows.h>
+#include "vulkan_win32.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_XCB_KHR
+#include <xcb/xcb.h>
+#include "vulkan_xcb.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+#include <X11/Xlib.h>
+#include "vulkan_xlib.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+#include <X11/Xlib.h>
+#include <X11/extensions/Xrandr.h>
+#include "vulkan_xlib_xrandr.h"
+#endif
+
+#endif // VULKAN_H_
@@ -0,0 +1,126 @@
+#ifndef VULKAN_ANDROID_H_
+#define VULKAN_ANDROID_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_KHR_android_surface 1
+struct ANativeWindow;
+
+#define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6
+#define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface"
+
+typedef VkFlags VkAndroidSurfaceCreateFlagsKHR;
+
+typedef struct VkAndroidSurfaceCreateInfoKHR {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkAndroidSurfaceCreateFlagsKHR    flags;
+    struct ANativeWindow*             window;
+} VkAndroidSurfaceCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(
+    VkInstance                                  instance,
+    const VkAndroidSurfaceCreateInfoKHR*        pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+#define VK_ANDROID_external_memory_android_hardware_buffer 1
+struct AHardwareBuffer;
+
+#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION 3
+#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME "VK_ANDROID_external_memory_android_hardware_buffer"
+
+typedef struct VkAndroidHardwareBufferUsageANDROID {
+    VkStructureType    sType;
+    void*              pNext;
+    uint64_t           androidHardwareBufferUsage;
+} VkAndroidHardwareBufferUsageANDROID;
+
+typedef struct VkAndroidHardwareBufferPropertiesANDROID {
+    VkStructureType    sType;
+    void*              pNext;
+    VkDeviceSize       allocationSize;
+    uint32_t           memoryTypeBits;
+} VkAndroidHardwareBufferPropertiesANDROID;
+
+typedef struct VkAndroidHardwareBufferFormatPropertiesANDROID {
+    VkStructureType                  sType;
+    void*                            pNext;
+    VkFormat                         format;
+    uint64_t                         externalFormat;
+    VkFormatFeatureFlags             formatFeatures;
+    VkComponentMapping               samplerYcbcrConversionComponents;
+    VkSamplerYcbcrModelConversion    suggestedYcbcrModel;
+    VkSamplerYcbcrRange              suggestedYcbcrRange;
+    VkChromaLocation                 suggestedXChromaOffset;
+    VkChromaLocation                 suggestedYChromaOffset;
+} VkAndroidHardwareBufferFormatPropertiesANDROID;
+
+typedef struct VkImportAndroidHardwareBufferInfoANDROID {
+    VkStructureType            sType;
+    const void*                pNext;
+    struct AHardwareBuffer*    buffer;
+} VkImportAndroidHardwareBufferInfoANDROID;
+
+typedef struct VkMemoryGetAndroidHardwareBufferInfoANDROID {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkDeviceMemory     memory;
+} VkMemoryGetAndroidHardwareBufferInfoANDROID;
+
+typedef struct VkExternalFormatANDROID {
+    VkStructureType    sType;
+    void*              pNext;
+    uint64_t           externalFormat;
+} VkExternalFormatANDROID;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetAndroidHardwareBufferPropertiesANDROID)(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryAndroidHardwareBufferANDROID)(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetAndroidHardwareBufferPropertiesANDROID(
+    VkDevice                                    device,
+    const struct AHardwareBuffer*               buffer,
+    VkAndroidHardwareBufferPropertiesANDROID*   pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID(
+    VkDevice                                    device,
+    const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
+    struct AHardwareBuffer**                    pBuffer);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
@@ -0,0 +1,58 @@
+#ifndef VULKAN_FUCHSIA_H_
+#define VULKAN_FUCHSIA_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_FUCHSIA_imagepipe_surface 1
+#define VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION 1
+#define VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME "VK_FUCHSIA_imagepipe_surface"
+
+typedef VkFlags VkImagePipeSurfaceCreateFlagsFUCHSIA;
+
+typedef struct VkImagePipeSurfaceCreateInfoFUCHSIA {
+    VkStructureType                         sType;
+    const void*                             pNext;
+    VkImagePipeSurfaceCreateFlagsFUCHSIA    flags;
+    zx_handle_t                             imagePipeHandle;
+} VkImagePipeSurfaceCreateInfoFUCHSIA;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateImagePipeSurfaceFUCHSIA)(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA(
+    VkInstance                                  instance,
+    const VkImagePipeSurfaceCreateInfoFUCHSIA*  pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
@@ -0,0 +1,58 @@
+#ifndef VULKAN_IOS_H_
+#define VULKAN_IOS_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_MVK_ios_surface 1
+#define VK_MVK_IOS_SURFACE_SPEC_VERSION   2
+#define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface"
+
+typedef VkFlags VkIOSSurfaceCreateFlagsMVK;
+
+typedef struct VkIOSSurfaceCreateInfoMVK {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkIOSSurfaceCreateFlagsMVK    flags;
+    const void*                   pView;
+} VkIOSSurfaceCreateInfoMVK;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(
+    VkInstance                                  instance,
+    const VkIOSSurfaceCreateInfoMVK*            pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
@@ -0,0 +1,58 @@
+#ifndef VULKAN_MACOS_H_
+#define VULKAN_MACOS_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_MVK_macos_surface 1
+#define VK_MVK_MACOS_SURFACE_SPEC_VERSION 2
+#define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface"
+
+typedef VkFlags VkMacOSSurfaceCreateFlagsMVK;
+
+typedef struct VkMacOSSurfaceCreateInfoMVK {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkMacOSSurfaceCreateFlagsMVK    flags;
+    const void*                     pView;
+} VkMacOSSurfaceCreateInfoMVK;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK(
+    VkInstance                                  instance,
+    const VkMacOSSurfaceCreateInfoMVK*          pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
@@ -0,0 +1,65 @@
+#ifndef VULKAN_MIR_H_
+#define VULKAN_MIR_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_KHR_mir_surface 1
+#define VK_KHR_MIR_SURFACE_SPEC_VERSION   4
+#define VK_KHR_MIR_SURFACE_EXTENSION_NAME "VK_KHR_mir_surface"
+
+typedef VkFlags VkMirSurfaceCreateFlagsKHR;
+
+typedef struct VkMirSurfaceCreateInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkMirSurfaceCreateFlagsKHR    flags;
+    MirConnection*                connection;
+    MirSurface*                   mirSurface;
+} VkMirSurfaceCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR(
+    VkInstance                                  instance,
+    const VkMirSurfaceCreateInfoKHR*            pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    MirConnection*                              connection);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
@@ -0,0 +1,58 @@
+#ifndef VULKAN_VI_H_
+#define VULKAN_VI_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_NN_vi_surface 1
+#define VK_NN_VI_SURFACE_SPEC_VERSION     1
+#define VK_NN_VI_SURFACE_EXTENSION_NAME   "VK_NN_vi_surface"
+
+typedef VkFlags VkViSurfaceCreateFlagsNN;
+
+typedef struct VkViSurfaceCreateInfoNN {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkViSurfaceCreateFlagsNN    flags;
+    void*                       window;
+} VkViSurfaceCreateInfoNN;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN(
+    VkInstance                                  instance,
+    const VkViSurfaceCreateInfoNN*              pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
@@ -0,0 +1,65 @@
+#ifndef VULKAN_WAYLAND_H_
+#define VULKAN_WAYLAND_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_KHR_wayland_surface 1
+#define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6
+#define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface"
+
+typedef VkFlags VkWaylandSurfaceCreateFlagsKHR;
+
+typedef struct VkWaylandSurfaceCreateInfoKHR {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkWaylandSurfaceCreateFlagsKHR    flags;
+    struct wl_display*                display;
+    struct wl_surface*                surface;
+} VkWaylandSurfaceCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(
+    VkInstance                                  instance,
+    const VkWaylandSurfaceCreateInfoKHR*        pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    struct wl_display*                          display);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
@@ -0,0 +1,276 @@
+#ifndef VULKAN_WIN32_H_
+#define VULKAN_WIN32_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_KHR_win32_surface 1
+#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6
+#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface"
+
+typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
+
+typedef struct VkWin32SurfaceCreateInfoKHR {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkWin32SurfaceCreateFlagsKHR    flags;
+    HINSTANCE                       hinstance;
+    HWND                            hwnd;
+} VkWin32SurfaceCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
+    VkInstance                                  instance,
+    const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex);
+#endif
+
+#define VK_KHR_external_memory_win32 1
+#define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32"
+
+typedef struct VkImportMemoryWin32HandleInfoKHR {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+    HANDLE                                handle;
+    LPCWSTR                               name;
+} VkImportMemoryWin32HandleInfoKHR;
+
+typedef struct VkExportMemoryWin32HandleInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    const SECURITY_ATTRIBUTES*    pAttributes;
+    DWORD                         dwAccess;
+    LPCWSTR                       name;
+} VkExportMemoryWin32HandleInfoKHR;
+
+typedef struct VkMemoryWin32HandlePropertiesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           memoryTypeBits;
+} VkMemoryWin32HandlePropertiesKHR;
+
+typedef struct VkMemoryGetWin32HandleInfoKHR {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkDeviceMemory                        memory;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+} VkMemoryGetWin32HandleInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(
+    VkDevice                                    device,
+    const VkMemoryGetWin32HandleInfoKHR*        pGetWin32HandleInfo,
+    HANDLE*                                     pHandle);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(
+    VkDevice                                    device,
+    VkExternalMemoryHandleTypeFlagBits          handleType,
+    HANDLE                                      handle,
+    VkMemoryWin32HandlePropertiesKHR*           pMemoryWin32HandleProperties);
+#endif
+
+#define VK_KHR_win32_keyed_mutex 1
+#define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1
+#define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex"
+
+typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR {
+    VkStructureType          sType;
+    const void*              pNext;
+    uint32_t                 acquireCount;
+    const VkDeviceMemory*    pAcquireSyncs;
+    const uint64_t*          pAcquireKeys;
+    const uint32_t*          pAcquireTimeouts;
+    uint32_t                 releaseCount;
+    const VkDeviceMemory*    pReleaseSyncs;
+    const uint64_t*          pReleaseKeys;
+} VkWin32KeyedMutexAcquireReleaseInfoKHR;
+
+
+
+#define VK_KHR_external_semaphore_win32 1
+#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32"
+
+typedef struct VkImportSemaphoreWin32HandleInfoKHR {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    VkSemaphore                              semaphore;
+    VkSemaphoreImportFlags                   flags;
+    VkExternalSemaphoreHandleTypeFlagBits    handleType;
+    HANDLE                                   handle;
+    LPCWSTR                                  name;
+} VkImportSemaphoreWin32HandleInfoKHR;
+
+typedef struct VkExportSemaphoreWin32HandleInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    const SECURITY_ATTRIBUTES*    pAttributes;
+    DWORD                         dwAccess;
+    LPCWSTR                       name;
+} VkExportSemaphoreWin32HandleInfoKHR;
+
+typedef struct VkD3D12FenceSubmitInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           waitSemaphoreValuesCount;
+    const uint64_t*    pWaitSemaphoreValues;
+    uint32_t           signalSemaphoreValuesCount;
+    const uint64_t*    pSignalSemaphoreValues;
+} VkD3D12FenceSubmitInfoKHR;
+
+typedef struct VkSemaphoreGetWin32HandleInfoKHR {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    VkSemaphore                              semaphore;
+    VkExternalSemaphoreHandleTypeFlagBits    handleType;
+} VkSemaphoreGetWin32HandleInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(
+    VkDevice                                    device,
+    const VkImportSemaphoreWin32HandleInfoKHR*  pImportSemaphoreWin32HandleInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(
+    VkDevice                                    device,
+    const VkSemaphoreGetWin32HandleInfoKHR*     pGetWin32HandleInfo,
+    HANDLE*                                     pHandle);
+#endif
+
+#define VK_KHR_external_fence_win32 1
+#define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32"
+
+typedef struct VkImportFenceWin32HandleInfoKHR {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkFence                              fence;
+    VkFenceImportFlags                   flags;
+    VkExternalFenceHandleTypeFlagBits    handleType;
+    HANDLE                               handle;
+    LPCWSTR                              name;
+} VkImportFenceWin32HandleInfoKHR;
+
+typedef struct VkExportFenceWin32HandleInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    const SECURITY_ATTRIBUTES*    pAttributes;
+    DWORD                         dwAccess;
+    LPCWSTR                       name;
+} VkExportFenceWin32HandleInfoKHR;
+
+typedef struct VkFenceGetWin32HandleInfoKHR {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkFence                              fence;
+    VkExternalFenceHandleTypeFlagBits    handleType;
+} VkFenceGetWin32HandleInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(
+    VkDevice                                    device,
+    const VkImportFenceWin32HandleInfoKHR*      pImportFenceWin32HandleInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(
+    VkDevice                                    device,
+    const VkFenceGetWin32HandleInfoKHR*         pGetWin32HandleInfo,
+    HANDLE*                                     pHandle);
+#endif
+
+#define VK_NV_external_memory_win32 1
+#define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
+#define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32"
+
+typedef struct VkImportMemoryWin32HandleInfoNV {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkExternalMemoryHandleTypeFlagsNV    handleType;
+    HANDLE                               handle;
+} VkImportMemoryWin32HandleInfoNV;
+
+typedef struct VkExportMemoryWin32HandleInfoNV {
+    VkStructureType               sType;
+    const void*                   pNext;
+    const SECURITY_ATTRIBUTES*    pAttributes;
+    DWORD                         dwAccess;
+} VkExportMemoryWin32HandleInfoNV;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
+    VkDevice                                    device,
+    VkDeviceMemory                              memory,
+    VkExternalMemoryHandleTypeFlagsNV           handleType,
+    HANDLE*                                     pHandle);
+#endif
+
+#define VK_NV_win32_keyed_mutex 1
+#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 1
+#define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex"
+
+typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
+    VkStructureType          sType;
+    const void*              pNext;
+    uint32_t                 acquireCount;
+    const VkDeviceMemory*    pAcquireSyncs;
+    const uint64_t*          pAcquireKeys;
+    const uint32_t*          pAcquireTimeoutMilliseconds;
+    uint32_t                 releaseCount;
+    const VkDeviceMemory*    pReleaseSyncs;
+    const uint64_t*          pReleaseKeys;
+} VkWin32KeyedMutexAcquireReleaseInfoNV;
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
@@ -0,0 +1,66 @@
+#ifndef VULKAN_XCB_H_
+#define VULKAN_XCB_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_KHR_xcb_surface 1
+#define VK_KHR_XCB_SURFACE_SPEC_VERSION   6
+#define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface"
+
+typedef VkFlags VkXcbSurfaceCreateFlagsKHR;
+
+typedef struct VkXcbSurfaceCreateInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkXcbSurfaceCreateFlagsKHR    flags;
+    xcb_connection_t*             connection;
+    xcb_window_t                  window;
+} VkXcbSurfaceCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(
+    VkInstance                                  instance,
+    const VkXcbSurfaceCreateInfoKHR*            pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    xcb_connection_t*                           connection,
+    xcb_visualid_t                              visual_id);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
@@ -0,0 +1,66 @@
+#ifndef VULKAN_XLIB_H_
+#define VULKAN_XLIB_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_KHR_xlib_surface 1
+#define VK_KHR_XLIB_SURFACE_SPEC_VERSION  6
+#define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface"
+
+typedef VkFlags VkXlibSurfaceCreateFlagsKHR;
+
+typedef struct VkXlibSurfaceCreateInfoKHR {
+    VkStructureType                sType;
+    const void*                    pNext;
+    VkXlibSurfaceCreateFlagsKHR    flags;
+    Display*                       dpy;
+    Window                         window;
+} VkXlibSurfaceCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(
+    VkInstance                                  instance,
+    const VkXlibSurfaceCreateInfoKHR*           pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    Display*                                    dpy,
+    VisualID                                    visualID);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
@@ -0,0 +1,54 @@
+#ifndef VULKAN_XLIB_XRANDR_H_
+#define VULKAN_XLIB_XRANDR_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_EXT_acquire_xlib_display 1
+#define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1
+#define VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_xlib_display"
+
+typedef VkResult (VKAPI_PTR *PFN_vkAcquireXlibDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display);
+typedef VkResult (VKAPI_PTR *PFN_vkGetRandROutputDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT(
+    VkPhysicalDevice                            physicalDevice,
+    Display*                                    dpy,
+    VkDisplayKHR                                display);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT(
+    VkPhysicalDevice                            physicalDevice,
+    Display*                                    dpy,
+    RROutput                                    rrOutput,
+    VkDisplayKHR*                               pDisplay);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
@@ -17,7 +17,7 @@ file(GLOB lib_hdrs ${IPP_IW_PATH}/include/*.h ${IPP_IW_PATH}/include/iw/*.h ${IP
 #         Define the library target:
 # ----------------------------------------------------------------------------------

-add_library(${IPP_IW_LIBRARY} STATIC ${OPENCV_3RDPARTY_EXCLUDE_FROM_ALL} ${lib_srcs} ${lib_hdrs})
+add_library(${IPP_IW_LIBRARY} STATIC ${lib_srcs} ${lib_hdrs})

 if(UNIX)
  if(CV_GCC OR CV_CLANG OR CV_ICC)
@@ -41,5 +41,5 @@ if(ENABLE_SOLUTION_FOLDERS)
 endif()

 if(NOT BUILD_SHARED_LIBS)
-  ocv_install_target(${IPP_IW_LIBRARY} EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev OPTIONAL)
+  ocv_install_target(${IPP_IW_LIBRARY} EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev)
 endif()
@@ -2,32 +2,37 @@ function(download_ippicv root_var)
  set(${root_var} "" PARENT_SCOPE)

  # Commit SHA in the opencv_3rdparty repo
-  set(IPPICV_COMMIT "1224f78da6684df04397ac0f40c961ed37f79ccb")
+  set(IPPICV_COMMIT "32e315a5b106a7b89dbed51c28f8120a48b368b4")
  # Define actual ICV versions
  if(APPLE)
    set(OPENCV_ICV_PLATFORM "macosx")
    set(OPENCV_ICV_PACKAGE_SUBDIR "ippicv_mac")
-    set(OPENCV_ICV_NAME "ippicv_2021.8_mac_intel64_20230330_general.tgz")
-    set(OPENCV_ICV_HASH "d2b234a86af1b616958619a4560356d9")
+    if(X86_64)
+      set(OPENCV_ICV_NAME "ippicv_2019_mac_intel64_general_20180723.tgz")
+      set(OPENCV_ICV_HASH "fe6b2bb75ae0e3f19ad3ae1a31dfa4a2")
+    else()
+      set(OPENCV_ICV_NAME "ippicv_2019_mac_ia32_general_20180723.tgz")
+      set(OPENCV_ICV_HASH "b5dfa78c87eb75c64470cbe5ec876f4f")
+    endif()
  elseif((UNIX AND NOT ANDROID) OR (UNIX AND ANDROID_ABI MATCHES "x86"))
    set(OPENCV_ICV_PLATFORM "linux")
    set(OPENCV_ICV_PACKAGE_SUBDIR "ippicv_lnx")
    if(X86_64)
-      set(OPENCV_ICV_NAME "ippicv_2021.8_lnx_intel64_20230330_general.tgz")
-      set(OPENCV_ICV_HASH "43219bdc7e3805adcbe3a1e2f1f3ef3b")
+      set(OPENCV_ICV_NAME "ippicv_2019_lnx_intel64_general_20180723.tgz")
+      set(OPENCV_ICV_HASH "c0bd78adb4156bbf552c1dfe90599607")
    else()
-      set(OPENCV_ICV_NAME "ippicv_2021.8_lnx_ia32_20230330_general.tgz")
-      set(OPENCV_ICV_HASH "165875443d72faa3fd2146869da90d07")
+      set(OPENCV_ICV_NAME "ippicv_2019_lnx_ia32_general_20180723.tgz")
+      set(OPENCV_ICV_HASH "4f38432c30bfd6423164b7a24bbc98a0")
    endif()
  elseif(WIN32 AND NOT ARM)
    set(OPENCV_ICV_PLATFORM "windows")
    set(OPENCV_ICV_PACKAGE_SUBDIR "ippicv_win")
    if(X86_64)
-      set(OPENCV_ICV_NAME "ippicv_2021.8_win_intel64_20230330_general.zip")
-      set(OPENCV_ICV_HASH "71e4f58de939f0348ec7fb58ffb17dbf")
+      set(OPENCV_ICV_NAME "ippicv_2019_win_intel64_20180723_general.zip")
+      set(OPENCV_ICV_HASH "1d222685246896fe089f88b8858e4b2f")
    else()
-      set(OPENCV_ICV_NAME "ippicv_2021.8_win_ia32_20230330_general.zip")
-      set(OPENCV_ICV_HASH "57fd4648cfe64eae9e2ad9d50173a553")
+      set(OPENCV_ICV_NAME "ippicv_2019_win_ia32_20180723_general.zip")
+      set(OPENCV_ICV_HASH "0157251a2eb9cd63a3ebc7eed0f3e59e")
    endif()
  else()
    return()
@@ -37,7 +37,7 @@ set(ITT_SRCS
    src/ittnotify/jitprofiling.c
 )

-add_library(${ITT_LIBRARY} STATIC ${OPENCV_3RDPARTY_EXCLUDE_FROM_ALL} ${ITT_SRCS} ${ITT_PUBLIC_HDRS} ${ITT_PRIVATE_HDRS})
+add_library(${ITT_LIBRARY} STATIC ${ITT_SRCS} ${ITT_PUBLIC_HDRS} ${ITT_PRIVATE_HDRS})

 if(NOT WIN32)
  if(HAVE_DL_LIBRARY)
@@ -60,7 +60,7 @@ if(ENABLE_SOLUTION_FOLDERS)
 endif()

 if(NOT BUILD_SHARED_LIBS)
-  ocv_install_target(${ITT_LIBRARY} EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev OPTIONAL)
+  ocv_install_target(${ITT_LIBRARY} EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev)
 endif()

 ocv_install_3rdparty_licenses(ittnotify src/ittnotify/LICENSE.BSD src/ittnotify/LICENSE.GPL)
@@ -196,10 +196,6 @@
 #  define ITT_ARCH_PPC64  5
 #endif /* ITT_ARCH_PPC64 */

-#ifndef ITT_ARCH_AARCH64  /* 64-bit ARM */
-#  define ITT_ARCH_AARCH64  6
-#endif /* ITT_ARCH_AARCH64 */
-
 #ifndef ITT_ARCH
 #  if defined _M_IX86 || defined __i386__
 #    define ITT_ARCH ITT_ARCH_IA32
@@ -209,8 +205,6 @@
 #    define ITT_ARCH ITT_ARCH_IA64
 #  elif defined _M_ARM || defined __arm__
 #    define ITT_ARCH ITT_ARCH_ARM
-#  elif defined __aarch64__
-#    define ITT_ARCH ITT_ARCH_AARCH64
 #  elif defined __powerpc64__
 #    define ITT_ARCH ITT_ARCH_PPC64
 #  endif
@@ -365,7 +359,7 @@ ITT_INLINE long __TBB_machine_fetchadd4(volatile void* ptr, long addend)
                          : "memory");
    return result;
 }
-#elif ITT_ARCH==ITT_ARCH_ARM || ITT_ARCH==ITT_ARCH_AARCH64 || ITT_ARCH==ITT_ARCH_PPC64
+#elif ITT_ARCH==ITT_ARCH_ARM || ITT_ARCH==ITT_ARCH_PPC64
 #define __TBB_machine_fetchadd4(addr, val) __sync_fetch_and_add(addr, val)
 #endif /* ITT_ARCH==ITT_ARCH_IA64 */
 #ifndef ITT_SIMPLE_INIT
@@ -17,7 +17,7 @@ file(GLOB lib_ext_hdrs jasper/*.h)
 #         Define the library target:
 # ----------------------------------------------------------------------------------

-add_library(${JASPER_LIBRARY} STATIC ${OPENCV_3RDPARTY_EXCLUDE_FROM_ALL} ${lib_srcs} ${lib_hdrs} ${lib_ext_hdrs})
+add_library(${JASPER_LIBRARY} STATIC ${lib_srcs} ${lib_hdrs} ${lib_ext_hdrs})

 if(WIN32 AND NOT MINGW)
  add_definitions(-DJAS_WIN_MSVC_BUILD)
@@ -46,7 +46,7 @@ if(ENABLE_SOLUTION_FOLDERS)
 endif()

 if(NOT BUILD_SHARED_LIBS)
-  ocv_install_target(${JASPER_LIBRARY} EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev OPTIONAL)
+  ocv_install_target(${JASPER_LIBRARY} EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev)
 endif()

 ocv_install_3rdparty_licenses(jasper LICENSE README copyright)
@@ -17,12 +17,6 @@
 #if !defined(JAS_WIN_MSVC_BUILD)
 /* A configure-based build is being used. */

-#include <stdio.h>
-
-// uClibc-ng workaround: https://github.com/opencv/opencv/pull/15279
-#ifndef L_tmpnam
-#define L_tmpnam 20
-#endif


 /* Extra debugging support */
@@ -2,11 +2,11 @@ project(${JPEG_LIBRARY} C)

 ocv_warnings_disable(CMAKE_C_FLAGS -Wunused-parameter -Wsign-compare -Wshorten-64-to-32 -Wimplicit-fallthrough)

-set(VERSION_MAJOR 2)
-set(VERSION_MINOR 1)
-set(VERSION_REVISION 2)
+set(VERSION_MAJOR 1)
+set(VERSION_MINOR 5)
+set(VERSION_REVISION 3)
 set(VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_REVISION})
-set(LIBJPEG_TURBO_VERSION_NUMBER 2001002)
+set(LIBJPEG_TURBO_VERSION_NUMBER 1005003)

 string(TIMESTAMP BUILD "opencv-${OPENCV_VERSION}-libjpeg-turbo")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
@@ -18,36 +18,15 @@ message(STATUS "libjpeg-turbo: VERSION = ${VERSION}, BUILD = ${BUILD}")
 option(WITH_ARITH_ENC "Include arithmetic encoding support when emulating the libjpeg v6b API/ABI" TRUE)
 option(WITH_ARITH_DEC "Include arithmetic decoding support when emulating the libjpeg v6b API/ABI" TRUE)

-include(CheckCSourceCompiles)
-include(CheckIncludeFiles)
-include(CheckTypeSize)
-
-check_type_size("size_t" SIZEOF_SIZE_T)
-check_type_size("unsigned long" SIZEOF_UNSIGNED_LONG)
-
-if(SIZEOF_SIZE_T EQUAL SIZEOF_UNSIGNED_LONG)
-  check_c_source_compiles("int main(int argc, char **argv) { unsigned long a = argc;  return __builtin_ctzl(a); }"
-    HAVE_BUILTIN_CTZL)
+if(NOT DEFINED SIZEOF_SIZE_T)
+  if(IOS)  # Workaround iOS issues
+    set(SIZEOF_SIZE_T "${CMAKE_SIZEOF_VOID_P}")
+    message(STATUS "SIZEOF_SIZE_T = ${SIZEOF_SIZE_T}")
+  else()
+    include(CheckTypeSize)
+    CHECK_TYPE_SIZE("size_t" SIZEOF_SIZE_T)
+  endif()
 endif()
-if(MSVC)
-  check_include_files("intrin.h" HAVE_INTRIN_H)
-endif()
-
-if(UNIX)
-  # Check for headers
-  check_include_files(locale.h HAVE_LOCALE_H)
-  check_include_files(stddef.h HAVE_STDDEF_H)
-  check_include_files(stdlib.h HAVE_STDLIB_H)
-  check_include_files(sys/types.h NEED_SYS_TYPES_H)
-
-  # Other predefines
-  # undef NEED_BSD_STRINGS
-  ocv_update(HAVE_UNSIGNED_CHAR 1)
-  ocv_update(HAVE_UNSIGNED_SHORT 1)
-  # undef INCOMPLETE_TYPES_BROKEN
-  ocv_update(RIGHT_SHIFT_IS_UNSIGNED 0)
-endif()
-

 set(BITS_IN_JSAMPLE 8)

@@ -64,26 +43,19 @@ 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()

-if(WIN32)
-  configure_file(jconfig.h.win.in jconfig.h)
-else()
-  configure_file(jconfig.h.in jconfig.h)
-endif()
+configure_file(jconfig.h.in jconfig.h)
 configure_file(jconfigint.h.in jconfigint.h)

 include_directories(${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/src)

-set(JPEG_SOURCES
-  jcapimin.c jcapistd.c jccoefct.c jccolor.c jcdctmgr.c jchuff.c jcicc.c
+set(JPEG_SOURCES jcapimin.c jcapistd.c jccoefct.c jccolor.c jcdctmgr.c jchuff.c
  jcinit.c jcmainct.c jcmarker.c jcmaster.c jcomapi.c jcparam.c jcphuff.c
  jcprepct.c jcsample.c jctrans.c jdapimin.c jdapistd.c jdatadst.c jdatasrc.c
-  jdcoefct.c jdcolor.c jddctmgr.c jdhuff.c jdicc.c jdinput.c jdmainct.c jdmarker.c
+  jdcoefct.c jdcolor.c jddctmgr.c jdhuff.c jdinput.c jdmainct.c jdmarker.c
  jdmaster.c jdmerge.c jdphuff.c jdpostct.c jdsample.c jdtrans.c jerror.c
  jfdctflt.c jfdctfst.c jfdctint.c jidctflt.c jidctfst.c jidctint.c jidctred.c
  jquant1.c jquant2.c jutils.c jmemmgr.c jmemnobs.c)
@@ -105,7 +77,7 @@ set(JPEG_SOURCES ${JPEG_SOURCES} jsimd_none.c)

 ocv_list_add_prefix(JPEG_SOURCES src/)

-add_library(${JPEG_LIBRARY} STATIC ${OPENCV_3RDPARTY_EXCLUDE_FROM_ALL} ${JPEG_SOURCES} ${SIMD_OBJS})
+add_library(${JPEG_LIBRARY} STATIC ${JPEG_SOURCES} ${SIMD_OBJS})

 set_target_properties(${JPEG_LIBRARY}
  PROPERTIES OUTPUT_NAME ${JPEG_LIBRARY}
@@ -120,7 +92,7 @@ if(ENABLE_SOLUTION_FOLDERS)
 endif()

 if(NOT BUILD_SHARED_LIBS)
-  ocv_install_target(${JPEG_LIBRARY} EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev OPTIONAL)
+  ocv_install_target(${JPEG_LIBRARY} EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev)
 endif()

 ocv_install_3rdparty_licenses(libjpeg-turbo README.md LICENSE.md README.ijg)
@@ -11,10 +11,9 @@ libjpeg-turbo is covered by three compatible BSD-style open source licenses:

 - The Modified (3-clause) BSD License, which is listed below

-  This license covers the TurboJPEG API library and associated programs, as
-  well as the build system.
+  This license covers the TurboJPEG API library and associated programs.

- The [zlib License](https://opensource.org/licenses/Zlib)
+- The zlib License, which is listed below

  This license is a subset of the other two, and it covers the libjpeg-turbo
  SIMD extensions.
@@ -66,7 +65,7 @@ best of our understanding.

    2.  If your binary distribution includes or uses the TurboJPEG API, then
        your product documentation must include the text of the Modified BSD
-        License (see below.)
+        License.

        **Origin**
        - Clause 2 of the Modified BSD License
@@ -91,8 +90,7 @@ best of our understanding.
 The Modified (3-clause) BSD License
 ===================================

-Copyright (C)2009-2021 D. R. Commander.  All Rights Reserved.<br>
-Copyright (C)2015 Viktor Szathmáry.  All Rights Reserved.
+Copyright (C)\<YEAR\> \<AUTHOR\>.  All Rights Reserved.

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
@@ -119,14 +117,23 @@ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.


-Why Three Licenses?
-===================
+The zlib License
+================

-The zlib License could have been used instead of the Modified (3-clause) BSD
-License, and since the IJG License effectively subsumes the distribution
-conditions of the zlib License, this would have effectively placed
-libjpeg-turbo binary distributions under the IJG License.  However, the IJG
-License specifically refers to the Independent JPEG Group and does not extend
-attribution and endorsement protections to other entities.  Thus, it was
-desirable to choose a license that granted us the same protections for new code
-that were granted to the IJG for code derived from their software.
+Copyright (C) \<YEAR\>, \<AUTHOR\>.
+
+This software is provided 'as-is', without any express or implied
+warranty.  In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not
+   claim that you wrote the original software. If you use this software
+   in a product, an acknowledgment in the product documentation would be
+   appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
@@ -43,7 +43,7 @@ User documentation:
  change.log        Version-to-version change highlights.
 Programmer and internal documentation:
  libjpeg.txt       How to use the JPEG library in your own programs.
-  example.txt       Sample code for calling the JPEG library.
+  example.c         Sample code for calling the JPEG library.
  structure.txt     Overview of the JPEG library's internal structure.
  coderules.txt     Coding style rules --- please read if you contribute code.

@@ -128,7 +128,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-2016, Thomas G. Lane, Guido Vollbeding.
 All Rights Reserved except as specified below.

 Permission is hereby granted to use, copy, modify, and distribute this
@@ -159,6 +159,25 @@ commercial products, provided that all warranty or liability claims are
 assumed by the product vendor.


+The Unix configuration script "configure" was produced with GNU Autoconf.
+It is copyright by the Free Software Foundation but is freely distributable.
+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.
+
+We are required to state that
+    "The Graphics Interchange Format(c) is the Copyright property of
+    CompuServe Incorporated.  GIF(sm) is a Service Mark property of
+    CompuServe Incorporated."
+
+
 REFERENCES
 ==========

@@ -166,8 +185,8 @@ We recommend reading one or more of these references before trying to
 understand the innards of the JPEG software.

 The best short technical introduction to the JPEG compression algorithm is
-        Wallace, Gregory K.  "The JPEG Still Picture Compression Standard",
-        Communications of the ACM, April 1991 (vol. 34 no. 4), pp. 30-44.
+	Wallace, Gregory K.  "The JPEG Still Picture Compression Standard",
+	Communications of the ACM, April 1991 (vol. 34 no. 4), pp. 30-44.
 (Adjacent articles in that issue discuss MPEG motion picture compression,
 applications of JPEG, and related topics.)  If you don't have the CACM issue
 handy, a PDF file containing a revised version of Wallace's article is
@@ -201,21 +220,21 @@ Continuous-tone Still Images, Part 2: Compliance testing" and has document
 numbers ISO/IEC IS 10918-2, ITU-T T.83.

 The JPEG standard does not specify all details of an interchangeable file
-format.  For the omitted details, we follow the "JFIF" conventions, revision
-1.02.  JFIF version 1 has been adopted as ISO/IEC 10918-5 (05/2013) and
-Recommendation ITU-T T.871 (05/2011): Information technology - Digital
-compression and coding of continuous-tone still images: JPEG File Interchange
-Format (JFIF).  It is available as a free download in PDF file format from
-https://www.iso.org/standard/54989.html and http://www.itu.int/rec/T-REC-T.871.
-A PDF file of the older JFIF 1.02 specification is available at
-http://www.w3.org/Graphics/JPEG/jfif3.pdf.
+format.  For the omitted details we follow the "JFIF" conventions, revision
+1.02.  JFIF 1.02 has been adopted as an Ecma International Technical Report
+and thus received a formal publication status.  It is available as a free
+download in PDF format from
+http://www.ecma-international.org/publications/techreports/E-TR-098.htm.
+A PostScript version of the JFIF document is available at
+http://www.ijg.org/files/jfif.ps.gz.  There is also a plain text version at
+http://www.ijg.org/files/jfif.txt.gz, but it is missing the figures.

-The TIFF 6.0 file format specification can be obtained from
-http://mirrors.ctan.org/graphics/tiff/TIFF6.ps.gz.  The JPEG incorporation
-scheme found in the TIFF 6.0 spec of 3-June-92 has a number of serious
-problems.  IJG does not recommend use of the TIFF 6.0 design (TIFF Compression
-tag 6).  Instead, we recommend the JPEG design proposed by TIFF Technical Note
-#2 (Compression tag 7).  Copies of this Note can be obtained from
+The TIFF 6.0 file format specification can be obtained by FTP from
+ftp://ftp.sgi.com/graphics/tiff/TIFF6.ps.gz.  The JPEG incorporation scheme
+found in the TIFF 6.0 spec of 3-June-92 has a number of serious problems.
+IJG does not recommend use of the TIFF 6.0 design (TIFF Compression tag 6).
+Instead, we recommend the JPEG design proposed by TIFF Technical Note #2
+(Compression tag 7).  Copies of this Note can be obtained from
 http://www.ijg.org/files/.  It is expected that the next revision
 of the TIFF spec will replace the 6.0 JPEG design with the Note's design.
 Although IJG's own code does not support TIFF/JPEG, the free libtiff library
@@ -230,26 +249,28 @@ The most recent released version can always be found there in
 directory "files".

 The JPEG FAQ (Frequently Asked Questions) article is a source of some
-general information about JPEG.  It is available at
-http://www.faqs.org/faqs/jpeg-faq.
+general information about JPEG.
+It is available on the World Wide Web at http://www.faqs.org/faqs/jpeg-faq/
+and other news.answers archive sites, including the official news.answers
+archive at rtfm.mit.edu: ftp://rtfm.mit.edu/pub/usenet/news.answers/jpeg-faq/.
+If you don't have Web or FTP access, send e-mail to mail-server@rtfm.mit.edu
+with body
+	send usenet/news.answers/jpeg-faq/part1
+	send usenet/news.answers/jpeg-faq/part2


-FILE FORMAT COMPATIBILITY
-=========================
+FILE FORMAT WARS
+================

-This software implements ITU T.81 | ISO/IEC 10918 with some extensions from
-ITU T.871 | ISO/IEC 10918-5 (JPEG File Interchange Format-- see REFERENCES).
-Informally, the term "JPEG image" or "JPEG file" most often refers to JFIF or
-a subset thereof, but there are other formats containing the name "JPEG" that
-are incompatible with the DCT-based JPEG standard or with JFIF (for instance,
-JPEG 2000 and JPEG XR).  This software therefore does not support these
-formats.  Indeed, one of the original reasons for developing this free software
-was to help force convergence on a common, interoperable format standard for
-JPEG files.
-
-JFIF is a minimal or "low end" representation.  TIFF/JPEG (TIFF revision 6.0 as
-modified by TIFF Technical Note #2) can be used for "high end" applications
-that need to record a lot of additional data about an image.
+The ISO/IEC JTC1/SC29/WG1 standards committee (also known as JPEG, together
+with ITU-T SG16) currently promotes different formats containing the name
+"JPEG" which are incompatible with original DCT-based JPEG.  IJG therefore does
+not support these formats (see REFERENCES).  Indeed, one of the original
+reasons for developing this free software was to help force convergence on
+common, interoperable format standards for JPEG files.
+Don't use an incompatible file format!
+(In any case, our decoder will remain capable of reading existing JPEG
+image files indefinitely.)


 TO DO
@@ -1,14 +1,13 @@
 Background
 ==========

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

 libjpeg-turbo implements both the traditional libjpeg API as well as the less
 powerful but more straightforward TurboJPEG API.  libjpeg-turbo also features
@@ -49,10 +48,7 @@ JPEG images:
  straightforward to achieve using the underlying libjpeg API, such as
  generating planar YUV images and performing multiple simultaneous lossless
  transforms on an image.  The Java interface for libjpeg-turbo is written on
-  top of the TurboJPEG API.  The TurboJPEG API is recommended for first-time
-  users of libjpeg-turbo.  Refer to [tjexample.c](tjexample.c) and
-  [TJExample.java](java/TJExample.java) for examples of its usage and to
-  <http://libjpeg-turbo.org/Documentation/Documentation> for API documentation.
+  top of the TurboJPEG API.

 - **libjpeg API**<br>
  This is the de facto industry-standard API for compressing and decompressing
@@ -60,8 +56,7 @@ JPEG images:
  more powerful.  The libjpeg API implementation in libjpeg-turbo is both
  API/ABI-compatible and mathematically compatible with libjpeg v6b.  It can
  also optionally be configured to be API/ABI-compatible with libjpeg v7 and v8
-  (see below.)  Refer to [cjpeg.c](cjpeg.c) and [djpeg.c](djpeg.c) for examples
-  of its usage and to [libjpeg.txt](libjpeg.txt) for API documentation.
+  (see below.)

 There is no significant performance advantage to either API when both are used
 to perform similar operations.
@@ -135,24 +130,25 @@ without recompiling.  libjpeg-turbo does not claim to support all of the
 libjpeg v7+ features, nor to produce identical output to libjpeg v7+ in all
 cases (see below.)

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

 ### Support for libjpeg v7 and v8 Features

 #### Fully supported

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

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

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

 - **cjpeg: Separate quality settings for luminance and chrominance**<br>
@@ -179,19 +175,19 @@ supported and which aren't.

 NOTE:  As of this writing, extensive research has been conducted into the
 usefulness of DCT scaling as a means of data reduction and SmartScale as a
-means of quality improvement.  Readers are invited to peruse the research at
-<http://www.libjpeg-turbo.org/About/SmartScale> and draw their own conclusions,
+means of quality improvement.  The reader is invited to peruse the research at
+<http://www.libjpeg-turbo.org/About/SmartScale> and draw his/her own conclusions,
 but it is the general belief of our project that these features have not
 demonstrated sufficient usefulness to justify inclusion in libjpeg-turbo.

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

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

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

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

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

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

 Note that, on most Un*x systems, the dynamic linker will not look for a
 function in a library until that function is actually used.  Thus, if a program
@@ -287,13 +284,12 @@ following reasons:
  (and slightly faster) floating point IDCT algorithm introduced in libjpeg
  v8a as opposed to the algorithm used in libjpeg v6b.  It should be noted,
  however, that this algorithm basically brings the accuracy of the floating
-  point IDCT in line with the accuracy of the accurate integer IDCT.  The
-  floating point DCT/IDCT algorithms are mainly a legacy feature, and they do
-  not produce significantly more accuracy than the accurate integer algorithms
-  (to put numbers on this, the typical difference in PNSR between the two
-  algorithms is less than 0.10 dB, whereas changing the quality level by 1 in
-  the upper range of the quality scale is typically more like a 1.0 dB
-  difference.)
+  point IDCT in line with the accuracy of the slow integer IDCT.  The floating
+  point DCT/IDCT algorithms are mainly a legacy feature, and they do not
+  produce significantly more accuracy than the slow integer algorithms (to put
+  numbers on this, the typical difference in PNSR between the two algorithms
+  is less than 0.10 dB, whereas changing the quality level by 1 in the upper
+  range of the quality scale is typically more like a 1.0 dB difference.)

 - If the floating point algorithms in libjpeg-turbo are not implemented using
  SIMD instructions on a particular platform, then the accuracy of the
@@ -330,7 +326,7 @@ in a way that makes the rest of the libjpeg infrastructure happy, so it is
 necessary to use the slow Huffman decoder when decompressing a JPEG image that
 has restart markers.  This can cause the decompression performance to drop by
 as much as 20%, but the performance will still be much greater than that of
-libjpeg.  Many consumer packages, such as Photoshop, use restart markers when
+libjpeg.  Many consumer packages, such as PhotoShop, use restart markers when
 generating JPEG images, so images generated by those programs will experience
 this issue.

@@ -341,17 +337,5 @@ The algorithm used by the SIMD-accelerated quantization function cannot produce
 correct results whenever the fast integer forward DCT is used along with a JPEG
 quality of 98-100.  Thus, libjpeg-turbo must use the non-SIMD quantization
 function in those cases.  This causes performance to drop by as much as 40%.
-It is therefore strongly advised that you use the accurate integer forward DCT
+It is therefore strongly advised that you use the slow integer forward DCT
 whenever encoding images with a JPEG quality of 98 or higher.
-
-
-Memory Debugger Pitfalls
-========================
-
-Valgrind and Memory Sanitizer (MSan) can generate false positives
-(specifically, incorrect reports of uninitialized memory accesses) when used
-with libjpeg-turbo's SIMD extensions.  It is generally recommended that the
-SIMD extensions be disabled, either by passing an argument of `-DWITH_SIMD=0`
-to `cmake` when configuring the build or by setting the environment variable
-`JSIMD_FORCENONE` to `1` at run time, when testing libjpeg-turbo with Valgrind,
-MSan, or other memory debuggers.
@@ -1,25 +1,12 @@
-/* Version ID for the JPEG library.
- * Might be useful for tests like "#if JPEG_LIB_VERSION >= 60".
- */
-#define JPEG_LIB_VERSION  @JPEG_LIB_VERSION@
+/* jconfig.vc --- jconfig.h for Microsoft Visual C++ on Windows 95 or NT. */
+/* see jconfig.txt for explanations */

-/* libjpeg-turbo version */
-#define LIBJPEG_TURBO_VERSION  @VERSION@
-
-/* libjpeg-turbo version in integer form */
-#define LIBJPEG_TURBO_VERSION_NUMBER  @LIBJPEG_TURBO_VERSION_NUMBER@
-
-/* Support arithmetic encoding */
-#cmakedefine C_ARITH_CODING_SUPPORTED 1
-
-/* Support arithmetic decoding */
-#cmakedefine D_ARITH_CODING_SUPPORTED 1
-
-/* Support in-memory source/destination managers */
-#cmakedefine MEM_SRCDST_SUPPORTED 1
-
-/* Use accelerated SIMD routines. */
-#cmakedefine WITH_SIMD 1
+#define JPEG_LIB_VERSION @JPEG_LIB_VERSION@
+#define LIBJPEG_TURBO_VERSION @VERSION@
+#define LIBJPEG_TURBO_VERSION_NUMBER @LIBJPEG_TURBO_VERSION_NUMBER@
+#cmakedefine C_ARITH_CODING_SUPPORTED
+#cmakedefine D_ARITH_CODING_SUPPORTED
+#cmakedefine MEM_SRCDST_SUPPORTED

 /*
 * Define BITS_IN_JSAMPLE as either
@@ -32,37 +19,35 @@

 #define BITS_IN_JSAMPLE  @BITS_IN_JSAMPLE@      /* use 8 or 12 */

-/* Define to 1 if you have the <locale.h> header file. */
-#cmakedefine HAVE_LOCALE_H 1
+#define HAVE_UNSIGNED_CHAR
+#define HAVE_UNSIGNED_SHORT
+/* #define void char */
+/* #define const */
+#undef __CHAR_UNSIGNED__
+#define HAVE_STDDEF_H
+#define HAVE_STDLIB_H
+#undef NEED_BSD_STRINGS
+#undef NEED_SYS_TYPES_H
+#undef NEED_FAR_POINTERS	/* we presume a 32-bit flat memory model */
+#undef INCOMPLETE_TYPES_BROKEN

-/* Define to 1 if you have the <stddef.h> header file. */
-#cmakedefine HAVE_STDDEF_H 1
+/* Define "boolean" as unsigned char, not int, per Windows custom */
+#ifndef __RPCNDR_H__		/* don't conflict if rpcndr.h already read */
+typedef unsigned char boolean;
+#endif
+#define HAVE_BOOLEAN		/* prevent jmorecfg.h from redefining it */

-/* Define to 1 if you have the <stdlib.h> header file. */
-#cmakedefine HAVE_STDLIB_H 1
+/* Define "INT32" as int, not long, per Windows custom */
+#if !(defined(_BASETSD_H_) || defined(_BASETSD_H))   /* don't conflict if basetsd.h already read */
+typedef short INT16;
+typedef signed int INT32;
+#endif
+#define XMD_H                   /* prevent jmorecfg.h from redefining it */

-/* Define if you need to include <sys/types.h> to get size_t. */
-#cmakedefine NEED_SYS_TYPES_H 1
+#ifdef JPEG_INTERNALS

-/* Define if you have BSD-like bzero and bcopy in <strings.h> rather than
-   memset/memcpy in <string.h>. */
-#cmakedefine NEED_BSD_STRINGS 1
+#undef RIGHT_SHIFT_IS_UNSIGNED

-/* Define to 1 if the system has the type `unsigned char'. */
-#cmakedefine HAVE_UNSIGNED_CHAR 1
+#define SIZEOF_SIZE_T @SIZEOF_SIZE_T@

-/* Define to 1 if the system has the type `unsigned short'. */
-#cmakedefine HAVE_UNSIGNED_SHORT 1
-
-/* Compiler does not support pointers to undefined structures. */
-#cmakedefine INCOMPLETE_TYPES_BROKEN 1
-
-/* Define if your (broken) compiler shifts signed values as if they were
-   unsigned. */
-#cmakedefine RIGHT_SHIFT_IS_UNSIGNED 1
-
-/* Define to empty if `const' does not conform to ANSI C. */
-/* #undef const */
-
-/* Define to `unsigned int' if <sys/types.h> does not define. */
-/* #undef size_t */
+#endif /* JPEG_INTERNALS */
@@ -1,33 +0,0 @@
-#define JPEG_LIB_VERSION  @JPEG_LIB_VERSION@
-#define LIBJPEG_TURBO_VERSION  @VERSION@
-#define LIBJPEG_TURBO_VERSION_NUMBER  @LIBJPEG_TURBO_VERSION_NUMBER@
-
-#cmakedefine C_ARITH_CODING_SUPPORTED
-#cmakedefine D_ARITH_CODING_SUPPORTED
-#cmakedefine MEM_SRCDST_SUPPORTED
-#cmakedefine WITH_SIMD
-
-#define BITS_IN_JSAMPLE  @BITS_IN_JSAMPLE@      /* use 8 or 12 */
-
-#define HAVE_STDDEF_H
-#define HAVE_STDLIB_H
-#undef NEED_SYS_TYPES_H
-#undef NEED_BSD_STRINGS
-
-#define HAVE_UNSIGNED_CHAR
-#define HAVE_UNSIGNED_SHORT
-#undef INCOMPLETE_TYPES_BROKEN
-#undef RIGHT_SHIFT_IS_UNSIGNED
-
-/* Define "boolean" as unsigned char, not int, per Windows custom */
-#ifndef __RPCNDR_H__            /* don't conflict if rpcndr.h already read */
-typedef unsigned char boolean;
-#endif
-#define HAVE_BOOLEAN            /* prevent jmorecfg.h from redefining it */
-
-/* Define "INT32" as int, not long, per Windows custom */
-#if !(defined(_BASETSD_H_) || defined(_BASETSD_H))   /* don't conflict if basetsd.h already read */
-typedef short INT16;
-typedef signed int INT32;
-#endif
-#define XMD_H                   /* prevent jmorecfg.h from redefining it */
@@ -1,10 +1,7 @@
-/* libjpeg-turbo build number */
-#define BUILD  "@BUILD@"
+#define VERSION "@VERSION@"
+#define BUILD "@BUILD@"
+#define PACKAGE_NAME "@CMAKE_PROJECT_NAME@"

-/* Compiler's inline keyword */
-#undef inline
-
-/* How to obtain function inlining. */
 #ifndef INLINE
 #if defined(__GNUC__)
 #define INLINE inline __attribute__((always_inline))
@@ -14,39 +11,3 @@
 #define INLINE
 #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@"
-
-/* Version number of package */
-#define VERSION  "@VERSION@"
-
-/* The size of `size_t', as computed by sizeof. */
-#define SIZEOF_SIZE_T  @SIZEOF_SIZE_T@
-
-/* Define if your compiler has __builtin_ctzl() and sizeof(unsigned long) == sizeof(size_t). */
-#cmakedefine HAVE_BUILTIN_CTZL
-
-/* Define to 1 if you have the <intrin.h> header file. */
-#cmakedefine HAVE_INTRIN_H
-
-#if defined(_MSC_VER) && defined(HAVE_INTRIN_H)
-#if (SIZEOF_SIZE_T == 8)
-#define HAVE_BITSCANFORWARD64
-#elif (SIZEOF_SIZE_T == 4)
-#define HAVE_BITSCANFORWARD
-#endif
-#endif
-
-#if defined(__has_attribute)
-#if __has_attribute(fallthrough)
-#define FALLTHROUGH  __attribute__((fallthrough));
-#else
-#define FALLTHROUGH
-#endif
-#else
-#define FALLTHROUGH
-#endif
@@ -4,16 +4,16 @@
 * This file was part of the Independent JPEG Group's software:
 * Developed 1997-2009 by Guido Vollbeding.
 * libjpeg-turbo Modifications:
- * Copyright (C) 2015, 2018, D. R. Commander.
+ * Copyright (C) 2015, D. R. Commander.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
 *
 * This file contains probability estimation tables for common use in
 * arithmetic entropy encoding and decoding routines.
 *
- * This data represents Table D.2 in
- * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994 and Table 24 in
- * Recommendation ITU-T T.82 (1993) | ISO/IEC 11544:1993.
+ * This data represents Table D.2 in the JPEG spec (ISO/IEC IS 10918-1
+ * and CCITT Recommendation ITU-T T.81) and Table 24 in the JBIG spec
+ * (ISO/IEC IS 11544 and CCITT Recommendation ITU-T T.82).
 */

 #define JPEG_INTERNALS
@@ -29,10 +29,9 @@
 * implementation (jbig_tab.c).
 */

-#define V(i, a, b, c, d) \
-  (((JLONG)a << 16) | ((JLONG)c << 8) | ((JLONG)d << 7) | b)
+#define V(i,a,b,c,d) (((JLONG)a << 16) | ((JLONG)c << 8) | ((JLONG)d << 7) | b)

-const JLONG jpeg_aritab[113 + 1] = {
+const JLONG jpeg_aritab[113+1] = {
 /*
 * Index, Qe_Value, Next_Index_LPS, Next_Index_MPS, Switch_MPS
 */
@@ -31,7 +31,7 @@
 */

 GLOBAL(void)
-jpeg_CreateCompress(j_compress_ptr cinfo, int version, size_t structsize)
+jpeg_CreateCompress (j_compress_ptr cinfo, int version, size_t structsize)
 {
  int i;

@@ -41,7 +41,7 @@ jpeg_CreateCompress(j_compress_ptr cinfo, int version, size_t structsize)
    ERREXIT2(cinfo, JERR_BAD_LIB_VERSION, JPEG_LIB_VERSION, version);
  if (structsize != sizeof(struct jpeg_compress_struct))
    ERREXIT2(cinfo, JERR_BAD_STRUCT_SIZE,
-             (int)sizeof(struct jpeg_compress_struct), (int)structsize);
+             (int) sizeof(struct jpeg_compress_struct), (int) structsize);

  /* For debugging purposes, we zero the whole master structure.
   * But the application has already set the err pointer, and may have set
@@ -59,7 +59,7 @@ jpeg_CreateCompress(j_compress_ptr cinfo, int version, size_t structsize)
  cinfo->is_decompressor = FALSE;

  /* Initialize a memory manager instance for this object */
-  jinit_memory_mgr((j_common_ptr)cinfo);
+  jinit_memory_mgr((j_common_ptr) cinfo);

  /* Zero out pointers to permanent structures. */
  cinfo->progress = NULL;
@@ -83,7 +83,7 @@ jpeg_CreateCompress(j_compress_ptr cinfo, int version, size_t structsize)
  /* Must do it here for emit_dqt in case jpeg_write_tables is used */
  cinfo->block_size = DCTSIZE;
  cinfo->natural_order = jpeg_natural_order;
-  cinfo->lim_Se = DCTSIZE2 - 1;
+  cinfo->lim_Se = DCTSIZE2-1;
 #endif

  cinfo->script_space = NULL;
@@ -100,9 +100,9 @@ jpeg_CreateCompress(j_compress_ptr cinfo, int version, size_t structsize)
 */

 GLOBAL(void)
-jpeg_destroy_compress(j_compress_ptr cinfo)
+jpeg_destroy_compress (j_compress_ptr cinfo)
 {
-  jpeg_destroy((j_common_ptr)cinfo); /* use common routine */
+  jpeg_destroy((j_common_ptr) cinfo); /* use common routine */
 }


@@ -112,9 +112,9 @@ jpeg_destroy_compress(j_compress_ptr cinfo)
 */

 GLOBAL(void)
-jpeg_abort_compress(j_compress_ptr cinfo)
+jpeg_abort_compress (j_compress_ptr cinfo)
 {
-  jpeg_abort((j_common_ptr)cinfo); /* use common routine */
+  jpeg_abort((j_common_ptr) cinfo); /* use common routine */
 }


@@ -131,7 +131,7 @@ jpeg_abort_compress(j_compress_ptr cinfo)
 */

 GLOBAL(void)
-jpeg_suppress_tables(j_compress_ptr cinfo, boolean suppress)
+jpeg_suppress_tables (j_compress_ptr cinfo, boolean suppress)
 {
  int i;
  JQUANT_TBL *qtbl;
@@ -159,7 +159,7 @@ jpeg_suppress_tables(j_compress_ptr cinfo, boolean suppress)
 */

 GLOBAL(void)
-jpeg_finish_compress(j_compress_ptr cinfo)
+jpeg_finish_compress (j_compress_ptr cinfo)
 {
  JDIMENSION iMCU_row;

@@ -172,18 +172,18 @@ jpeg_finish_compress(j_compress_ptr cinfo)
  } else if (cinfo->global_state != CSTATE_WRCOEFS)
    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
  /* Perform any remaining passes */
-  while (!cinfo->master->is_last_pass) {
+  while (! cinfo->master->is_last_pass) {
    (*cinfo->master->prepare_for_pass) (cinfo);
    for (iMCU_row = 0; iMCU_row < cinfo->total_iMCU_rows; iMCU_row++) {
      if (cinfo->progress != NULL) {
-        cinfo->progress->pass_counter = (long)iMCU_row;
-        cinfo->progress->pass_limit = (long)cinfo->total_iMCU_rows;
-        (*cinfo->progress->progress_monitor) ((j_common_ptr)cinfo);
+        cinfo->progress->pass_counter = (long) iMCU_row;
+        cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows;
+        (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
      }
      /* We bypass the main controller and invoke coef controller directly;
       * all work is being done from the coefficient buffer.
       */
-      if (!(*cinfo->coef->compress_data) (cinfo, (JSAMPIMAGE)NULL))
+      if (! (*cinfo->coef->compress_data) (cinfo, (JSAMPIMAGE) NULL))
        ERREXIT(cinfo, JERR_CANT_SUSPEND);
    }
    (*cinfo->master->finish_pass) (cinfo);
@@ -192,7 +192,7 @@ jpeg_finish_compress(j_compress_ptr cinfo)
  (*cinfo->marker->write_file_trailer) (cinfo);
  (*cinfo->dest->term_destination) (cinfo);
  /* We can use jpeg_abort to release memory and reset global_state */
-  jpeg_abort((j_common_ptr)cinfo);
+  jpeg_abort((j_common_ptr) cinfo);
 }


@@ -204,8 +204,8 @@ jpeg_finish_compress(j_compress_ptr cinfo)
 */

 GLOBAL(void)
-jpeg_write_marker(j_compress_ptr cinfo, int marker, const JOCTET *dataptr,
-                  unsigned int datalen)
+jpeg_write_marker (j_compress_ptr cinfo, int marker,
+                   const JOCTET *dataptr, unsigned int datalen)
 {
  void (*write_marker_byte) (j_compress_ptr info, int val);

@@ -226,7 +226,7 @@ jpeg_write_marker(j_compress_ptr cinfo, int marker, const JOCTET *dataptr,
 /* Same, but piecemeal. */

 GLOBAL(void)
-jpeg_write_m_header(j_compress_ptr cinfo, int marker, unsigned int datalen)
+jpeg_write_m_header (j_compress_ptr cinfo, int marker, unsigned int datalen)
 {
  if (cinfo->next_scanline != 0 ||
      (cinfo->global_state != CSTATE_SCANNING &&
@@ -238,7 +238,7 @@ jpeg_write_m_header(j_compress_ptr cinfo, int marker, unsigned int datalen)
 }

 GLOBAL(void)
-jpeg_write_m_byte(j_compress_ptr cinfo, int val)
+jpeg_write_m_byte (j_compress_ptr cinfo, int val)
 {
  (*cinfo->marker->write_marker_byte) (cinfo, val);
 }
@@ -266,13 +266,13 @@ jpeg_write_m_byte(j_compress_ptr cinfo, int val)
 */

 GLOBAL(void)
-jpeg_write_tables(j_compress_ptr cinfo)
+jpeg_write_tables (j_compress_ptr cinfo)
 {
  if (cinfo->global_state != CSTATE_START)
    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);

  /* (Re)initialize error mgr and destination modules */
-  (*cinfo->err->reset_error_mgr) ((j_common_ptr)cinfo);
+  (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
  (*cinfo->dest->init_destination) (cinfo);
  /* Initialize the marker writer ... bit of a crock to do it here. */
  jinit_marker_writer(cinfo);
@@ -36,7 +36,7 @@
 */

 GLOBAL(void)
-jpeg_start_compress(j_compress_ptr cinfo, boolean write_all_tables)
+jpeg_start_compress (j_compress_ptr cinfo, boolean write_all_tables)
 {
  if (cinfo->global_state != CSTATE_START)
    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
@@ -45,7 +45,7 @@ jpeg_start_compress(j_compress_ptr cinfo, boolean write_all_tables)
    jpeg_suppress_tables(cinfo, FALSE); /* mark all tables to be written */

  /* (Re)initialize error mgr and destination modules */
-  (*cinfo->err->reset_error_mgr) ((j_common_ptr)cinfo);
+  (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
  (*cinfo->dest->init_destination) (cinfo);
  /* Perform master selection of active modules */
  jinit_compress_master(cinfo);
@@ -75,8 +75,8 @@ jpeg_start_compress(j_compress_ptr cinfo, boolean write_all_tables)
 */

 GLOBAL(JDIMENSION)
-jpeg_write_scanlines(j_compress_ptr cinfo, JSAMPARRAY scanlines,
-                     JDIMENSION num_lines)
+jpeg_write_scanlines (j_compress_ptr cinfo, JSAMPARRAY scanlines,
+                      JDIMENSION num_lines)
 {
  JDIMENSION row_ctr, rows_left;

@@ -87,9 +87,9 @@ jpeg_write_scanlines(j_compress_ptr cinfo, JSAMPARRAY scanlines,

  /* Call progress monitor hook if present */
  if (cinfo->progress != NULL) {
-    cinfo->progress->pass_counter = (long)cinfo->next_scanline;
-    cinfo->progress->pass_limit = (long)cinfo->image_height;
-    (*cinfo->progress->progress_monitor) ((j_common_ptr)cinfo);
+    cinfo->progress->pass_counter = (long) cinfo->next_scanline;
+    cinfo->progress->pass_limit = (long) cinfo->image_height;
+    (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
  }

  /* Give master control module another chance if this is first call to
@@ -118,8 +118,8 @@ jpeg_write_scanlines(j_compress_ptr cinfo, JSAMPARRAY scanlines,
 */

 GLOBAL(JDIMENSION)
-jpeg_write_raw_data(j_compress_ptr cinfo, JSAMPIMAGE data,
-                    JDIMENSION num_lines)
+jpeg_write_raw_data (j_compress_ptr cinfo, JSAMPIMAGE data,
+                     JDIMENSION num_lines)
 {
  JDIMENSION lines_per_iMCU_row;

@@ -132,9 +132,9 @@ jpeg_write_raw_data(j_compress_ptr cinfo, JSAMPIMAGE data,

  /* Call progress monitor hook if present */
  if (cinfo->progress != NULL) {
-    cinfo->progress->pass_counter = (long)cinfo->next_scanline;
-    cinfo->progress->pass_limit = (long)cinfo->image_height;
-    (*cinfo->progress->progress_monitor) ((j_common_ptr)cinfo);
+    cinfo->progress->pass_counter = (long) cinfo->next_scanline;
+    cinfo->progress->pass_limit = (long) cinfo->image_height;
+    (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
  }

  /* Give master control module another chance if this is first call to
@@ -151,7 +151,7 @@ jpeg_write_raw_data(j_compress_ptr cinfo, JSAMPIMAGE data,
    ERREXIT(cinfo, JERR_BUFFER_SIZE);

  /* Directly compress the row. */
-  if (!(*cinfo->coef->compress_data) (cinfo, data)) {
+  if (! (*cinfo->coef->compress_data) (cinfo, data)) {
    /* If compressor did not consume the whole row, suspend processing. */
    return 0;
  }
@@ -4,19 +4,16 @@
 * This file was part of the Independent JPEG Group's software:
 * Developed 1997-2009 by Guido Vollbeding.
 * libjpeg-turbo Modifications:
- * Copyright (C) 2015, 2018, D. R. Commander.
+ * Copyright (C) 2015, D. R. Commander.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
 *
 * This file contains portable arithmetic entropy encoding routines for JPEG
- * (implementing Recommendation ITU-T T.81 | ISO/IEC 10918-1).
+ * (implementing the ISO/IEC IS 10918-1 and CCITT Recommendation ITU-T T.81).
 *
 * Both sequential and progressive modes are supported in this single module.
 *
 * Suspension is not currently supported in this module.
- *
- * NOTE: All referenced figures are from
- * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994.
 */

 #define JPEG_INTERNALS
@@ -66,8 +63,8 @@ typedef arith_entropy_encoder *arith_entropy_ptr;
 * in the lower bits (mask 0x7F).
 */

-#define DC_STAT_BINS  64
-#define AC_STAT_BINS  256
+#define DC_STAT_BINS 64
+#define AC_STAT_BINS 256

 /* NOTE: Uncomment the following #define if you want to use the
 * given formula for calculating the AC conditioning parameter Kx
@@ -108,25 +105,25 @@ typedef arith_entropy_encoder *arith_entropy_ptr;

 #ifdef RIGHT_SHIFT_IS_UNSIGNED
 #define ISHIFT_TEMPS    int ishift_temp;
-#define IRIGHT_SHIFT(x, shft) \
-  ((ishift_temp = (x)) < 0 ? \
-   (ishift_temp >> (shft)) | ((~0) << (16 - (shft))) : \
-   (ishift_temp >> (shft)))
+#define IRIGHT_SHIFT(x,shft)  \
+        ((ishift_temp = (x)) < 0 ? \
+         (ishift_temp >> (shft)) | ((~0) << (16-(shft))) : \
+         (ishift_temp >> (shft)))
 #else
 #define ISHIFT_TEMPS
-#define IRIGHT_SHIFT(x, shft)   ((x) >> (shft))
+#define IRIGHT_SHIFT(x,shft)    ((x) >> (shft))
 #endif


 LOCAL(void)
-emit_byte(int val, j_compress_ptr cinfo)
+emit_byte (int val, j_compress_ptr cinfo)
 /* Write next output byte; we do not support suspension in this module. */
 {
  struct jpeg_destination_mgr *dest = cinfo->dest;

-  *dest->next_output_byte++ = (JOCTET)val;
+  *dest->next_output_byte++ = (JOCTET) val;
  if (--dest->free_in_buffer == 0)
-    if (!(*dest->empty_output_buffer) (cinfo))
+    if (! (*dest->empty_output_buffer) (cinfo))
      ERREXIT(cinfo, JERR_CANT_SUSPEND);
 }

@@ -136,22 +133,22 @@ emit_byte(int val, j_compress_ptr cinfo)
 */

 METHODDEF(void)
-finish_pass(j_compress_ptr cinfo)
+finish_pass (j_compress_ptr cinfo)
 {
-  arith_entropy_ptr e = (arith_entropy_ptr)cinfo->entropy;
+  arith_entropy_ptr e = (arith_entropy_ptr) cinfo->entropy;
  JLONG temp;

  /* Section D.1.8: Termination of encoding */

  /* Find the e->c in the coding interval with the largest
   * number of trailing zero bits */
-  if ((temp = (e->a - 1 + e->c) & 0xFFFF0000UL) < e->c)
+  if ((temp = (e->a - 1 + e->c) & 0xFFFF0000L) < e->c)
    e->c = temp + 0x8000L;
  else
    e->c = temp;
  /* Send remaining bytes to output */
  e->c <<= e->ct;
-  if (e->c & 0xF8000000UL) {
+  if (e->c & 0xF8000000L) {
    /* One final overflow has to be handled */
    if (e->buffer >= 0) {
      if (e->zc)
@@ -222,9 +219,9 @@ finish_pass(j_compress_ptr cinfo)
 */

 LOCAL(void)
-arith_encode(j_compress_ptr cinfo, unsigned char *st, int val)
+arith_encode (j_compress_ptr cinfo, unsigned char *st, int val)
 {
-  register arith_entropy_ptr e = (arith_entropy_ptr)cinfo->entropy;
+  register arith_entropy_ptr e = (arith_entropy_ptr) cinfo->entropy;
  register unsigned char nl, nm;
  register JLONG qe, temp;
  register int sv;
@@ -234,8 +231,8 @@ arith_encode(j_compress_ptr cinfo, unsigned char *st, int val)
   */
  sv = *st;
  qe = jpeg_aritab[sv & 0x7F];  /* => Qe_Value */
-  nl = qe & 0xFF;  qe >>= 8;    /* Next_Index_LPS + Switch_MPS */
-  nm = qe & 0xFF;  qe >>= 8;    /* Next_Index_MPS */
+  nl = qe & 0xFF; qe >>= 8;     /* Next_Index_LPS + Switch_MPS */
+  nm = qe & 0xFF; qe >>= 8;     /* Next_Index_MPS */

  /* Encode & estimation procedures per sections D.1.4 & D.1.5 */
  e->a -= qe;
@@ -322,9 +319,9 @@ arith_encode(j_compress_ptr cinfo, unsigned char *st, int val)
 */

 LOCAL(void)
-emit_restart(j_compress_ptr cinfo, int restart_num)
+emit_restart (j_compress_ptr cinfo, int restart_num)
 {
-  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
  int ci;
  jpeg_component_info *compptr;

@@ -365,9 +362,9 @@ emit_restart(j_compress_ptr cinfo, int restart_num)
 */

 METHODDEF(boolean)
-encode_mcu_DC_first(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+encode_mcu_DC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
 {
-  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
  JBLOCKROW block;
  unsigned char *st;
  int blkn, ci, tbl;
@@ -394,7 +391,7 @@ encode_mcu_DC_first(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
    /* Compute the DC value after the required point transform by Al.
     * This is simply an arithmetic right shift.
     */
-    m = IRIGHT_SHIFT((int)((*block)[0]), cinfo->Al);
+    m = IRIGHT_SHIFT((int) ((*block)[0]), cinfo->Al);

    /* Sections F.1.4.1 & F.1.4.4.1: Encoding of DC coefficients */

@@ -435,9 +432,9 @@ encode_mcu_DC_first(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
      }
      arith_encode(cinfo, st, 0);
      /* Section F.1.4.4.1.2: Establish dc_context conditioning category */
-      if (m < (int)((1L << cinfo->arith_dc_L[tbl]) >> 1))
+      if (m < (int) ((1L << cinfo->arith_dc_L[tbl]) >> 1))
        entropy->dc_context[ci] = 0;    /* zero diff category */
-      else if (m > (int)((1L << cinfo->arith_dc_U[tbl]) >> 1))
+      else if (m > (int) ((1L << cinfo->arith_dc_U[tbl]) >> 1))
        entropy->dc_context[ci] += 8;   /* large diff category */
      /* Figure F.9: Encoding the magnitude bit pattern of v */
      st += 14;
@@ -456,9 +453,9 @@ encode_mcu_DC_first(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
 */

 METHODDEF(boolean)
-encode_mcu_AC_first(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+encode_mcu_AC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
 {
-  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
  JBLOCKROW block;
  unsigned char *st;
  int tbl, k, ke;
@@ -513,7 +510,7 @@ encode_mcu_AC_first(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
          break;
        }
      }
-      arith_encode(cinfo, st + 1, 0);  st += 3;  k++;
+      arith_encode(cinfo, st + 1, 0); st += 3; k++;
    }
    st += 2;
    /* Figure F.8: Encoding the magnitude category of v */
@@ -555,9 +552,9 @@ encode_mcu_AC_first(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
 */

 METHODDEF(boolean)
-encode_mcu_DC_refine(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+encode_mcu_DC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
 {
-  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
  unsigned char *st;
  int Al, blkn;

@@ -590,9 +587,9 @@ encode_mcu_DC_refine(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
 */

 METHODDEF(boolean)
-encode_mcu_AC_refine(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+encode_mcu_AC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
 {
-  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
  JBLOCKROW block;
  unsigned char *st;
  int tbl, k, ke, kex;
@@ -665,7 +662,7 @@ encode_mcu_AC_refine(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
          break;
        }
      }
-      arith_encode(cinfo, st + 1, 0);  st += 3;  k++;
+      arith_encode(cinfo, st + 1, 0); st += 3; k++;
    }
  }
  /* Encode EOB decision only if k <= cinfo->Se */
@@ -683,9 +680,9 @@ encode_mcu_AC_refine(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
 */

 METHODDEF(boolean)
-encode_mcu(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+encode_mcu (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
 {
-  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
  jpeg_component_info *compptr;
  JBLOCKROW block;
  unsigned char *st;
@@ -750,9 +747,9 @@ encode_mcu(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
      }
      arith_encode(cinfo, st, 0);
      /* Section F.1.4.4.1.2: Establish dc_context conditioning category */
-      if (m < (int)((1L << cinfo->arith_dc_L[tbl]) >> 1))
+      if (m < (int) ((1L << cinfo->arith_dc_L[tbl]) >> 1))
        entropy->dc_context[ci] = 0;    /* zero diff category */
-      else if (m > (int)((1L << cinfo->arith_dc_U[tbl]) >> 1))
+      else if (m > (int) ((1L << cinfo->arith_dc_U[tbl]) >> 1))
        entropy->dc_context[ci] += 8;   /* large diff category */
      /* Figure F.9: Encoding the magnitude bit pattern of v */
      st += 14;
@@ -773,7 +770,7 @@ encode_mcu(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
      st = entropy->ac_stats[tbl] + 3 * (k - 1);
      arith_encode(cinfo, st, 0);       /* EOB decision */
      while ((v = (*block)[jpeg_natural_order[k]]) == 0) {
-        arith_encode(cinfo, st + 1, 0);  st += 3;  k++;
+        arith_encode(cinfo, st + 1, 0); st += 3; k++;
      }
      arith_encode(cinfo, st + 1, 1);
      /* Figure F.6: Encoding nonzero value v */
@@ -825,9 +822,9 @@ encode_mcu(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
 */

 METHODDEF(void)
-start_pass(j_compress_ptr cinfo, boolean gather_statistics)
+start_pass (j_compress_ptr cinfo, boolean gather_statistics)
 {
-  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
  int ci, tbl;
  jpeg_component_info *compptr;

@@ -865,8 +862,8 @@ start_pass(j_compress_ptr cinfo, boolean gather_statistics)
      if (tbl < 0 || tbl >= NUM_ARITH_TBLS)
        ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl);
      if (entropy->dc_stats[tbl] == NULL)
-        entropy->dc_stats[tbl] = (unsigned char *)(*cinfo->mem->alloc_small)
-          ((j_common_ptr)cinfo, JPOOL_IMAGE, DC_STAT_BINS);
+        entropy->dc_stats[tbl] = (unsigned char *) (*cinfo->mem->alloc_small)
+          ((j_common_ptr) cinfo, JPOOL_IMAGE, DC_STAT_BINS);
      MEMZERO(entropy->dc_stats[tbl], DC_STAT_BINS);
      /* Initialize DC predictions to 0 */
      entropy->last_dc_val[ci] = 0;
@@ -878,14 +875,13 @@ start_pass(j_compress_ptr cinfo, boolean gather_statistics)
      if (tbl < 0 || tbl >= NUM_ARITH_TBLS)
        ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl);
      if (entropy->ac_stats[tbl] == NULL)
-        entropy->ac_stats[tbl] = (unsigned char *)(*cinfo->mem->alloc_small)
-          ((j_common_ptr)cinfo, JPOOL_IMAGE, AC_STAT_BINS);
+        entropy->ac_stats[tbl] = (unsigned char *) (*cinfo->mem->alloc_small)
+          ((j_common_ptr) cinfo, JPOOL_IMAGE, AC_STAT_BINS);
      MEMZERO(entropy->ac_stats[tbl], AC_STAT_BINS);
 #ifdef CALCULATE_SPECTRAL_CONDITIONING
      if (cinfo->progressive_mode)
        /* Section G.1.3.2: Set appropriate arithmetic conditioning value Kx */
-        cinfo->arith_ac_K[tbl] = cinfo->Ss +
-                                 ((8 + cinfo->Se - cinfo->Ss) >> 4);
+        cinfo->arith_ac_K[tbl] = cinfo->Ss + ((8 + cinfo->Se - cinfo->Ss) >> 4);
 #endif
    }
  }
@@ -909,15 +905,15 @@ start_pass(j_compress_ptr cinfo, boolean gather_statistics)
 */

 GLOBAL(void)
-jinit_arith_encoder(j_compress_ptr cinfo)
+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,
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                sizeof(arith_entropy_encoder));
-  cinfo->entropy = (struct jpeg_entropy_encoder *)entropy;
+  cinfo->entropy = (struct jpeg_entropy_encoder *) entropy;
  entropy->pub.start_pass = start_pass;
  entropy->pub.finish_pass = finish_pass;

@@ -58,19 +58,21 @@ typedef my_coef_controller *my_coef_ptr;


 /* Forward declarations */
-METHODDEF(boolean) compress_data(j_compress_ptr cinfo, JSAMPIMAGE input_buf);
+METHODDEF(boolean) compress_data
+        (j_compress_ptr cinfo, JSAMPIMAGE input_buf);
 #ifdef FULL_COEF_BUFFER_SUPPORTED
-METHODDEF(boolean) compress_first_pass(j_compress_ptr cinfo,
-                                       JSAMPIMAGE input_buf);
-METHODDEF(boolean) compress_output(j_compress_ptr cinfo, JSAMPIMAGE input_buf);
+METHODDEF(boolean) compress_first_pass
+        (j_compress_ptr cinfo, JSAMPIMAGE input_buf);
+METHODDEF(boolean) compress_output
+        (j_compress_ptr cinfo, JSAMPIMAGE input_buf);
 #endif


 LOCAL(void)
-start_iMCU_row(j_compress_ptr cinfo)
+start_iMCU_row (j_compress_ptr cinfo)
 /* Reset within-iMCU-row counters for a new row */
 {
-  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;

  /* In an interleaved scan, an MCU row is the same as an iMCU row.
   * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
@@ -79,7 +81,7 @@ start_iMCU_row(j_compress_ptr cinfo)
  if (cinfo->comps_in_scan > 1) {
    coef->MCU_rows_per_iMCU_row = 1;
  } else {
-    if (coef->iMCU_row_num < (cinfo->total_iMCU_rows - 1))
+    if (coef->iMCU_row_num < (cinfo->total_iMCU_rows-1))
      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
    else
      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
@@ -95,9 +97,9 @@ start_iMCU_row(j_compress_ptr cinfo)
 */

 METHODDEF(void)
-start_pass_coef(j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+start_pass_coef (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
 {
-  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;

  coef->iMCU_row_num = 0;
  start_iMCU_row(cinfo);
@@ -138,9 +140,9 @@ start_pass_coef(j_compress_ptr cinfo, J_BUF_MODE pass_mode)
 */

 METHODDEF(boolean)
-compress_data(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+compress_data (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
 {
-  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
  JDIMENSION MCU_col_num;       /* index of current MCU within row */
  JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
@@ -165,33 +167,31 @@ compress_data(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
      blkn = 0;
      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
        compptr = cinfo->cur_comp_info[ci];
-        blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width :
-                                                  compptr->last_col_width;
+        blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
+                                                : compptr->last_col_width;
        xpos = MCU_col_num * compptr->MCU_sample_width;
        ypos = yoffset * DCTSIZE; /* ypos == (yoffset+yindex) * DCTSIZE */
        for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
          if (coef->iMCU_row_num < last_iMCU_row ||
-              yoffset + yindex < compptr->last_row_height) {
+              yoffset+yindex < compptr->last_row_height) {
            (*cinfo->fdct->forward_DCT) (cinfo, compptr,
                                         input_buf[compptr->component_index],
                                         coef->MCU_buffer[blkn],
-                                         ypos, xpos, (JDIMENSION)blockcnt);
+                                         ypos, xpos, (JDIMENSION) blockcnt);
            if (blockcnt < compptr->MCU_width) {
              /* Create some dummy blocks at the right edge of the image. */
-              jzero_far((void *)coef->MCU_buffer[blkn + blockcnt],
+              jzero_far((void *) coef->MCU_buffer[blkn + blockcnt],
                        (compptr->MCU_width - blockcnt) * sizeof(JBLOCK));
              for (bi = blockcnt; bi < compptr->MCU_width; bi++) {
-                coef->MCU_buffer[blkn + bi][0][0] =
-                  coef->MCU_buffer[blkn + bi - 1][0][0];
+                coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn+bi-1][0][0];
              }
            }
          } else {
            /* Create a row of dummy blocks at the bottom of the image. */
-            jzero_far((void *)coef->MCU_buffer[blkn],
+            jzero_far((void *) coef->MCU_buffer[blkn],
                      compptr->MCU_width * sizeof(JBLOCK));
            for (bi = 0; bi < compptr->MCU_width; bi++) {
-              coef->MCU_buffer[blkn + bi][0][0] =
-                coef->MCU_buffer[blkn - 1][0][0];
+              coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn-1][0][0];
            }
          }
          blkn += compptr->MCU_width;
@@ -201,7 +201,7 @@ compress_data(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
      /* Try to write the MCU.  In event of a suspension failure, we will
       * re-DCT the MCU on restart (a bit inefficient, could be fixed...)
       */
-      if (!(*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
+      if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
        /* Suspension forced; update state counters and exit */
        coef->MCU_vert_offset = yoffset;
        coef->mcu_ctr = MCU_col_num;
@@ -242,9 +242,9 @@ compress_data(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
 */

 METHODDEF(boolean)
-compress_first_pass(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+compress_first_pass (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
 {
-  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
  JDIMENSION blocks_across, MCUs_across, MCUindex;
  int bi, ci, h_samp_factor, block_row, block_rows, ndummy;
@@ -257,21 +257,21 @@ compress_first_pass(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
       ci++, compptr++) {
    /* Align the virtual buffer for this component. */
    buffer = (*cinfo->mem->access_virt_barray)
-      ((j_common_ptr)cinfo, coef->whole_image[ci],
+      ((j_common_ptr) cinfo, coef->whole_image[ci],
       coef->iMCU_row_num * compptr->v_samp_factor,
-       (JDIMENSION)compptr->v_samp_factor, TRUE);
+       (JDIMENSION) compptr->v_samp_factor, TRUE);
    /* Count non-dummy DCT block rows in this iMCU row. */
    if (coef->iMCU_row_num < last_iMCU_row)
      block_rows = compptr->v_samp_factor;
    else {
      /* NB: can't use last_row_height here, since may not be set! */
-      block_rows = (int)(compptr->height_in_blocks % compptr->v_samp_factor);
+      block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
      if (block_rows == 0) block_rows = compptr->v_samp_factor;
    }
    blocks_across = compptr->width_in_blocks;
    h_samp_factor = compptr->h_samp_factor;
    /* Count number of dummy blocks to be added at the right margin. */
-    ndummy = (int)(blocks_across % h_samp_factor);
+    ndummy = (int) (blocks_across % h_samp_factor);
    if (ndummy > 0)
      ndummy = h_samp_factor - ndummy;
    /* Perform DCT for all non-dummy blocks in this iMCU row.  Each call
@@ -281,12 +281,12 @@ compress_first_pass(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
      thisblockrow = buffer[block_row];
      (*cinfo->fdct->forward_DCT) (cinfo, compptr,
                                   input_buf[ci], thisblockrow,
-                                   (JDIMENSION)(block_row * DCTSIZE),
-                                   (JDIMENSION)0, blocks_across);
+                                   (JDIMENSION) (block_row * DCTSIZE),
+                                   (JDIMENSION) 0, blocks_across);
      if (ndummy > 0) {
        /* Create dummy blocks at the right edge of the image. */
        thisblockrow += blocks_across; /* => first dummy block */
-        jzero_far((void *)thisblockrow, ndummy * sizeof(JBLOCK));
+        jzero_far((void *) thisblockrow, ndummy * sizeof(JBLOCK));
        lastDC = thisblockrow[-1][0];
        for (bi = 0; bi < ndummy; bi++) {
          thisblockrow[bi][0] = lastDC;
@@ -304,11 +304,11 @@ compress_first_pass(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
      for (block_row = block_rows; block_row < compptr->v_samp_factor;
           block_row++) {
        thisblockrow = buffer[block_row];
-        lastblockrow = buffer[block_row - 1];
-        jzero_far((void *)thisblockrow,
-                  (size_t)(blocks_across * sizeof(JBLOCK)));
+        lastblockrow = buffer[block_row-1];
+        jzero_far((void *) thisblockrow,
+                  (size_t) (blocks_across * sizeof(JBLOCK)));
        for (MCUindex = 0; MCUindex < MCUs_across; MCUindex++) {
-          lastDC = lastblockrow[h_samp_factor - 1][0];
+          lastDC = lastblockrow[h_samp_factor-1][0];
          for (bi = 0; bi < h_samp_factor; bi++) {
            thisblockrow[bi][0] = lastDC;
          }
@@ -338,9 +338,9 @@ compress_first_pass(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
 */

 METHODDEF(boolean)
-compress_output(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
 {
-  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
  JDIMENSION MCU_col_num;       /* index of current MCU within row */
  int blkn, ci, xindex, yindex, yoffset;
  JDIMENSION start_col;
@@ -355,9 +355,9 @@ compress_output(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
    compptr = cinfo->cur_comp_info[ci];
    buffer[ci] = (*cinfo->mem->access_virt_barray)
-      ((j_common_ptr)cinfo, coef->whole_image[compptr->component_index],
+      ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index],
       coef->iMCU_row_num * compptr->v_samp_factor,
-       (JDIMENSION)compptr->v_samp_factor, FALSE);
+       (JDIMENSION) compptr->v_samp_factor, FALSE);
  }

  /* Loop to process one whole iMCU row */
@@ -371,14 +371,14 @@ compress_output(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
        compptr = cinfo->cur_comp_info[ci];
        start_col = MCU_col_num * compptr->MCU_width;
        for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
-          buffer_ptr = buffer[ci][yindex + yoffset] + start_col;
+          buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
          for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
            coef->MCU_buffer[blkn++] = buffer_ptr++;
          }
        }
      }
      /* Try to write the MCU. */
-      if (!(*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
+      if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
        /* Suspension forced; update state counters and exit */
        coef->MCU_vert_offset = yoffset;
        coef->mcu_ctr = MCU_col_num;
@@ -402,14 +402,14 @@ compress_output(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
 */

 GLOBAL(void)
-jinit_c_coef_controller(j_compress_ptr cinfo, boolean need_full_buffer)
+jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer)
 {
  my_coef_ptr coef;

  coef = (my_coef_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                sizeof(my_coef_controller));
-  cinfo->coef = (struct jpeg_c_coef_controller *)coef;
+  cinfo->coef = (struct jpeg_c_coef_controller *) coef;
  coef->pub.start_pass = start_pass_coef;

  /* Create the coefficient buffer. */
@@ -423,12 +423,12 @@ jinit_c_coef_controller(j_compress_ptr cinfo, boolean need_full_buffer)
    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
         ci++, compptr++) {
      coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
-        ((j_common_ptr)cinfo, JPOOL_IMAGE, FALSE,
-         (JDIMENSION)jround_up((long)compptr->width_in_blocks,
-                               (long)compptr->h_samp_factor),
-         (JDIMENSION)jround_up((long)compptr->height_in_blocks,
-                               (long)compptr->v_samp_factor),
-         (JDIMENSION)compptr->v_samp_factor);
+        ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
+         (JDIMENSION) jround_up((long) compptr->width_in_blocks,
+                                (long) compptr->h_samp_factor),
+         (JDIMENSION) jround_up((long) compptr->height_in_blocks,
+                                (long) compptr->v_samp_factor),
+         (JDIMENSION) compptr->v_samp_factor);
    }
 #else
    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
@@ -439,7 +439,7 @@ jinit_c_coef_controller(j_compress_ptr cinfo, boolean need_full_buffer)
    int i;

    buffer = (JBLOCKROW)
-      (*cinfo->mem->alloc_large) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+      (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                  C_MAX_BLOCKS_IN_MCU * sizeof(JBLOCK));
    for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
      coef->MCU_buffer[i] = buffer + i;
@@ -29,13 +29,13 @@

 INLINE
 LOCAL(void)
-rgb_ycc_convert_internal(j_compress_ptr cinfo, JSAMPARRAY input_buf,
-                         JSAMPIMAGE output_buf, JDIMENSION output_row,
-                         int num_rows)
+rgb_ycc_convert_internal (j_compress_ptr cinfo,
+                          JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+                          JDIMENSION output_row, int num_rows)
 {
-  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
  register int r, g, b;
-  register JLONG *ctab = cconvert->rgb_ycc_tab;
+  register JLONG * ctab = cconvert->rgb_ycc_tab;
  register JSAMPROW inptr;
  register JSAMPROW outptr0, outptr1, outptr2;
  register JDIMENSION col;
@@ -48,9 +48,9 @@ rgb_ycc_convert_internal(j_compress_ptr cinfo, JSAMPARRAY input_buf,
    outptr2 = output_buf[2][output_row];
    output_row++;
    for (col = 0; col < num_cols; col++) {
-      r = inptr[RGB_RED];
-      g = inptr[RGB_GREEN];
-      b = inptr[RGB_BLUE];
+      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.
@@ -58,14 +58,17 @@ rgb_ycc_convert_internal(j_compress_ptr cinfo, JSAMPARRAY input_buf,
       * need the general RIGHT_SHIFT macro.
       */
      /* Y */
-      outptr0[col] = (JSAMPLE)((ctab[r + R_Y_OFF] + ctab[g + G_Y_OFF] +
-                                ctab[b + B_Y_OFF]) >> SCALEBITS);
+      outptr0[col] = (JSAMPLE)
+                ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+                 >> SCALEBITS);
      /* Cb */
-      outptr1[col] = (JSAMPLE)((ctab[r + R_CB_OFF] + ctab[g + G_CB_OFF] +
-                                ctab[b + B_CB_OFF]) >> SCALEBITS);
+      outptr1[col] = (JSAMPLE)
+                ((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
+                 >> SCALEBITS);
      /* Cr */
-      outptr2[col] = (JSAMPLE)((ctab[r + R_CR_OFF] + ctab[g + G_CR_OFF] +
-                                ctab[b + B_CR_OFF]) >> SCALEBITS);
+      outptr2[col] = (JSAMPLE)
+                ((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
+                 >> SCALEBITS);
    }
  }
 }
@@ -83,13 +86,13 @@ rgb_ycc_convert_internal(j_compress_ptr cinfo, JSAMPARRAY input_buf,

 INLINE
 LOCAL(void)
-rgb_gray_convert_internal(j_compress_ptr cinfo, JSAMPARRAY input_buf,
-                          JSAMPIMAGE output_buf, JDIMENSION output_row,
-                          int num_rows)
+rgb_gray_convert_internal (j_compress_ptr cinfo,
+                           JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+                           JDIMENSION output_row, int num_rows)
 {
-  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
  register int r, g, b;
-  register JLONG *ctab = cconvert->rgb_ycc_tab;
+  register JLONG * ctab = cconvert->rgb_ycc_tab;
  register JSAMPROW inptr;
  register JSAMPROW outptr;
  register JDIMENSION col;
@@ -100,13 +103,14 @@ rgb_gray_convert_internal(j_compress_ptr cinfo, JSAMPARRAY input_buf,
    outptr = output_buf[0][output_row];
    output_row++;
    for (col = 0; col < num_cols; col++) {
-      r = inptr[RGB_RED];
-      g = inptr[RGB_GREEN];
-      b = inptr[RGB_BLUE];
+      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);
+      outptr[col] = (JSAMPLE)
+                ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+                 >> SCALEBITS);
    }
  }
 }
@@ -119,9 +123,9 @@ rgb_gray_convert_internal(j_compress_ptr cinfo, JSAMPARRAY input_buf,

 INLINE
 LOCAL(void)
-rgb_rgb_convert_internal(j_compress_ptr cinfo, JSAMPARRAY input_buf,
-                         JSAMPIMAGE output_buf, JDIMENSION output_row,
-                         int num_rows)
+rgb_rgb_convert_internal (j_compress_ptr cinfo,
+                          JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+                          JDIMENSION output_row, int num_rows)
 {
  register JSAMPROW inptr;
  register JSAMPROW outptr0, outptr1, outptr2;
@@ -135,9 +139,9 @@ rgb_rgb_convert_internal(j_compress_ptr cinfo, JSAMPARRAY input_buf,
    outptr2 = output_buf[2][output_row];
    output_row++;
    for (col = 0; col < num_cols; col++) {
-      outptr0[col] = inptr[RGB_RED];
-      outptr1[col] = inptr[RGB_GREEN];
-      outptr2[col] = inptr[RGB_BLUE];
+      outptr0[col] = GETJSAMPLE(inptr[RGB_RED]);
+      outptr1[col] = GETJSAMPLE(inptr[RGB_GREEN]);
+      outptr2[col] = GETJSAMPLE(inptr[RGB_BLUE]);
      inptr += RGB_PIXELSIZE;
    }
  }
@@ -63,9 +63,9 @@ typedef my_color_converter *my_cconvert_ptr;
 */

 #define SCALEBITS       16      /* speediest right-shift on some machines */
-#define CBCR_OFFSET     ((JLONG)CENTERJSAMPLE << SCALEBITS)
-#define ONE_HALF        ((JLONG)1 << (SCALEBITS - 1))
-#define FIX(x)          ((JLONG)((x) * (1L << SCALEBITS) + 0.5))
+#define CBCR_OFFSET     ((JLONG) CENTERJSAMPLE << SCALEBITS)
+#define ONE_HALF        ((JLONG) 1 << (SCALEBITS-1))
+#define FIX(x)          ((JLONG) ((x) * (1L<<SCALEBITS) + 0.5))

 /* We allocate one big table and divide it up into eight parts, instead of
 * doing eight alloc_small requests.  This lets us use a single table base
@@ -74,15 +74,15 @@ typedef my_color_converter *my_cconvert_ptr;
 */

 #define R_Y_OFF         0                       /* offset to R => Y section */
-#define G_Y_OFF         (1 * (MAXJSAMPLE + 1))  /* offset to G => Y section */
-#define B_Y_OFF         (2 * (MAXJSAMPLE + 1))  /* etc. */
-#define R_CB_OFF        (3 * (MAXJSAMPLE + 1))
-#define G_CB_OFF        (4 * (MAXJSAMPLE + 1))
-#define B_CB_OFF        (5 * (MAXJSAMPLE + 1))
+#define G_Y_OFF         (1*(MAXJSAMPLE+1))      /* offset to G => Y section */
+#define B_Y_OFF         (2*(MAXJSAMPLE+1))      /* etc. */
+#define R_CB_OFF        (3*(MAXJSAMPLE+1))
+#define G_CB_OFF        (4*(MAXJSAMPLE+1))
+#define B_CB_OFF        (5*(MAXJSAMPLE+1))
 #define R_CR_OFF        B_CB_OFF                /* B=>Cb, R=>Cr are the same */
-#define G_CR_OFF        (6 * (MAXJSAMPLE + 1))
-#define B_CR_OFF        (7 * (MAXJSAMPLE + 1))
-#define TABLE_SIZE      (8 * (MAXJSAMPLE + 1))
+#define G_CR_OFF        (6*(MAXJSAMPLE+1))
+#define B_CR_OFF        (7*(MAXJSAMPLE+1))
+#define TABLE_SIZE      (8*(MAXJSAMPLE+1))


 /* Include inline routines for colorspace extensions */
@@ -93,13 +93,13 @@ typedef my_color_converter *my_cconvert_ptr;
 #undef RGB_BLUE
 #undef RGB_PIXELSIZE

-#define RGB_RED  EXT_RGB_RED
-#define RGB_GREEN  EXT_RGB_GREEN
-#define RGB_BLUE  EXT_RGB_BLUE
-#define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
-#define rgb_ycc_convert_internal  extrgb_ycc_convert_internal
-#define rgb_gray_convert_internal  extrgb_gray_convert_internal
-#define rgb_rgb_convert_internal  extrgb_rgb_convert_internal
+#define RGB_RED EXT_RGB_RED
+#define RGB_GREEN EXT_RGB_GREEN
+#define RGB_BLUE EXT_RGB_BLUE
+#define RGB_PIXELSIZE EXT_RGB_PIXELSIZE
+#define rgb_ycc_convert_internal extrgb_ycc_convert_internal
+#define rgb_gray_convert_internal extrgb_gray_convert_internal
+#define rgb_rgb_convert_internal extrgb_rgb_convert_internal
 #include "jccolext.c"
 #undef RGB_RED
 #undef RGB_GREEN
@@ -109,13 +109,13 @@ typedef my_color_converter *my_cconvert_ptr;
 #undef rgb_gray_convert_internal
 #undef rgb_rgb_convert_internal

-#define RGB_RED  EXT_RGBX_RED
-#define RGB_GREEN  EXT_RGBX_GREEN
-#define RGB_BLUE  EXT_RGBX_BLUE
-#define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
-#define rgb_ycc_convert_internal  extrgbx_ycc_convert_internal
-#define rgb_gray_convert_internal  extrgbx_gray_convert_internal
-#define rgb_rgb_convert_internal  extrgbx_rgb_convert_internal
+#define RGB_RED EXT_RGBX_RED
+#define RGB_GREEN EXT_RGBX_GREEN
+#define RGB_BLUE EXT_RGBX_BLUE
+#define RGB_PIXELSIZE EXT_RGBX_PIXELSIZE
+#define rgb_ycc_convert_internal extrgbx_ycc_convert_internal
+#define rgb_gray_convert_internal extrgbx_gray_convert_internal
+#define rgb_rgb_convert_internal extrgbx_rgb_convert_internal
 #include "jccolext.c"
 #undef RGB_RED
 #undef RGB_GREEN
@@ -125,13 +125,13 @@ typedef my_color_converter *my_cconvert_ptr;
 #undef rgb_gray_convert_internal
 #undef rgb_rgb_convert_internal

-#define RGB_RED  EXT_BGR_RED
-#define RGB_GREEN  EXT_BGR_GREEN
-#define RGB_BLUE  EXT_BGR_BLUE
-#define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
-#define rgb_ycc_convert_internal  extbgr_ycc_convert_internal
-#define rgb_gray_convert_internal  extbgr_gray_convert_internal
-#define rgb_rgb_convert_internal  extbgr_rgb_convert_internal
+#define RGB_RED EXT_BGR_RED
+#define RGB_GREEN EXT_BGR_GREEN
+#define RGB_BLUE EXT_BGR_BLUE
+#define RGB_PIXELSIZE EXT_BGR_PIXELSIZE
+#define rgb_ycc_convert_internal extbgr_ycc_convert_internal
+#define rgb_gray_convert_internal extbgr_gray_convert_internal
+#define rgb_rgb_convert_internal extbgr_rgb_convert_internal
 #include "jccolext.c"
 #undef RGB_RED
 #undef RGB_GREEN
@@ -141,13 +141,13 @@ typedef my_color_converter *my_cconvert_ptr;
 #undef rgb_gray_convert_internal
 #undef rgb_rgb_convert_internal

-#define RGB_RED  EXT_BGRX_RED
-#define RGB_GREEN  EXT_BGRX_GREEN
-#define RGB_BLUE  EXT_BGRX_BLUE
-#define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
-#define rgb_ycc_convert_internal  extbgrx_ycc_convert_internal
-#define rgb_gray_convert_internal  extbgrx_gray_convert_internal
-#define rgb_rgb_convert_internal  extbgrx_rgb_convert_internal
+#define RGB_RED EXT_BGRX_RED
+#define RGB_GREEN EXT_BGRX_GREEN
+#define RGB_BLUE EXT_BGRX_BLUE
+#define RGB_PIXELSIZE EXT_BGRX_PIXELSIZE
+#define rgb_ycc_convert_internal extbgrx_ycc_convert_internal
+#define rgb_gray_convert_internal extbgrx_gray_convert_internal
+#define rgb_rgb_convert_internal extbgrx_rgb_convert_internal
 #include "jccolext.c"
 #undef RGB_RED
 #undef RGB_GREEN
@@ -157,13 +157,13 @@ typedef my_color_converter *my_cconvert_ptr;
 #undef rgb_gray_convert_internal
 #undef rgb_rgb_convert_internal

-#define RGB_RED  EXT_XBGR_RED
-#define RGB_GREEN  EXT_XBGR_GREEN
-#define RGB_BLUE  EXT_XBGR_BLUE
-#define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
-#define rgb_ycc_convert_internal  extxbgr_ycc_convert_internal
-#define rgb_gray_convert_internal  extxbgr_gray_convert_internal
-#define rgb_rgb_convert_internal  extxbgr_rgb_convert_internal
+#define RGB_RED EXT_XBGR_RED
+#define RGB_GREEN EXT_XBGR_GREEN
+#define RGB_BLUE EXT_XBGR_BLUE
+#define RGB_PIXELSIZE EXT_XBGR_PIXELSIZE
+#define rgb_ycc_convert_internal extxbgr_ycc_convert_internal
+#define rgb_gray_convert_internal extxbgr_gray_convert_internal
+#define rgb_rgb_convert_internal extxbgr_rgb_convert_internal
 #include "jccolext.c"
 #undef RGB_RED
 #undef RGB_GREEN
@@ -173,13 +173,13 @@ typedef my_color_converter *my_cconvert_ptr;
 #undef rgb_gray_convert_internal
 #undef rgb_rgb_convert_internal

-#define RGB_RED  EXT_XRGB_RED
-#define RGB_GREEN  EXT_XRGB_GREEN
-#define RGB_BLUE  EXT_XRGB_BLUE
-#define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
-#define rgb_ycc_convert_internal  extxrgb_ycc_convert_internal
-#define rgb_gray_convert_internal  extxrgb_gray_convert_internal
-#define rgb_rgb_convert_internal  extxrgb_rgb_convert_internal
+#define RGB_RED EXT_XRGB_RED
+#define RGB_GREEN EXT_XRGB_GREEN
+#define RGB_BLUE EXT_XRGB_BLUE
+#define RGB_PIXELSIZE EXT_XRGB_PIXELSIZE
+#define rgb_ycc_convert_internal extxrgb_ycc_convert_internal
+#define rgb_gray_convert_internal extxrgb_gray_convert_internal
+#define rgb_rgb_convert_internal extxrgb_rgb_convert_internal
 #include "jccolext.c"
 #undef RGB_RED
 #undef RGB_GREEN
@@ -195,33 +195,33 @@ typedef my_color_converter *my_cconvert_ptr;
 */

 METHODDEF(void)
-rgb_ycc_start(j_compress_ptr cinfo)
+rgb_ycc_start (j_compress_ptr cinfo)
 {
-  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
  JLONG *rgb_ycc_tab;
  JLONG i;

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

  for (i = 0; i <= MAXJSAMPLE; i++) {
-    rgb_ycc_tab[i + R_Y_OFF] = FIX(0.29900) * i;
-    rgb_ycc_tab[i + G_Y_OFF] = FIX(0.58700) * i;
-    rgb_ycc_tab[i + B_Y_OFF] = FIX(0.11400) * i   + ONE_HALF;
-    rgb_ycc_tab[i + R_CB_OFF] = (-FIX(0.16874)) * i;
-    rgb_ycc_tab[i + G_CB_OFF] = (-FIX(0.33126)) * i;
+    rgb_ycc_tab[i+R_Y_OFF] = FIX(0.29900) * i;
+    rgb_ycc_tab[i+G_Y_OFF] = FIX(0.58700) * i;
+    rgb_ycc_tab[i+B_Y_OFF] = FIX(0.11400) * i     + ONE_HALF;
+    rgb_ycc_tab[i+R_CB_OFF] = (-FIX(0.16874)) * i;
+    rgb_ycc_tab[i+G_CB_OFF] = (-FIX(0.33126)) * 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.
     */
-    rgb_ycc_tab[i + B_CB_OFF] = FIX(0.50000) * i  + CBCR_OFFSET + ONE_HALF - 1;
+    rgb_ycc_tab[i+B_CB_OFF] = FIX(0.50000) * i    + CBCR_OFFSET + ONE_HALF-1;
 /*  B=>Cb and R=>Cr tables are the same
-    rgb_ycc_tab[i + R_CR_OFF] = FIX(0.50000) * i  + CBCR_OFFSET + ONE_HALF - 1;
+    rgb_ycc_tab[i+R_CR_OFF] = FIX(0.50000) * i    + CBCR_OFFSET + ONE_HALF-1;
 */
-    rgb_ycc_tab[i + G_CR_OFF] = (-FIX(0.41869)) * i;
-    rgb_ycc_tab[i + B_CR_OFF] = (-FIX(0.08131)) * i;
+    rgb_ycc_tab[i+G_CR_OFF] = (-FIX(0.41869)) * i;
+    rgb_ycc_tab[i+B_CR_OFF] = (-FIX(0.08131)) * i;
  }
 }

@@ -231,42 +231,43 @@ rgb_ycc_start(j_compress_ptr cinfo)
 */

 METHODDEF(void)
-rgb_ycc_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
-                JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows)
+rgb_ycc_convert (j_compress_ptr cinfo,
+                 JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+                 JDIMENSION output_row, int num_rows)
 {
  switch (cinfo->in_color_space) {
-  case JCS_EXT_RGB:
-    extrgb_ycc_convert_internal(cinfo, input_buf, output_buf, output_row,
-                                num_rows);
-    break;
-  case JCS_EXT_RGBX:
-  case JCS_EXT_RGBA:
-    extrgbx_ycc_convert_internal(cinfo, input_buf, output_buf, output_row,
-                                 num_rows);
-    break;
-  case JCS_EXT_BGR:
-    extbgr_ycc_convert_internal(cinfo, input_buf, output_buf, output_row,
-                                num_rows);
-    break;
-  case JCS_EXT_BGRX:
-  case JCS_EXT_BGRA:
-    extbgrx_ycc_convert_internal(cinfo, input_buf, output_buf, output_row,
-                                 num_rows);
-    break;
-  case JCS_EXT_XBGR:
-  case JCS_EXT_ABGR:
-    extxbgr_ycc_convert_internal(cinfo, input_buf, output_buf, output_row,
-                                 num_rows);
-    break;
-  case JCS_EXT_XRGB:
-  case JCS_EXT_ARGB:
-    extxrgb_ycc_convert_internal(cinfo, input_buf, output_buf, output_row,
-                                 num_rows);
-    break;
-  default:
-    rgb_ycc_convert_internal(cinfo, input_buf, output_buf, output_row,
-                             num_rows);
-    break;
+    case JCS_EXT_RGB:
+      extrgb_ycc_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                  num_rows);
+      break;
+    case JCS_EXT_RGBX:
+    case JCS_EXT_RGBA:
+      extrgbx_ycc_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                   num_rows);
+      break;
+    case JCS_EXT_BGR:
+      extbgr_ycc_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                  num_rows);
+      break;
+    case JCS_EXT_BGRX:
+    case JCS_EXT_BGRA:
+      extbgrx_ycc_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                   num_rows);
+      break;
+    case JCS_EXT_XBGR:
+    case JCS_EXT_ABGR:
+      extxbgr_ycc_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                   num_rows);
+      break;
+    case JCS_EXT_XRGB:
+    case JCS_EXT_ARGB:
+      extxrgb_ycc_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                   num_rows);
+      break;
+    default:
+      rgb_ycc_convert_internal(cinfo, input_buf, output_buf, output_row,
+                               num_rows);
+      break;
  }
 }

@@ -279,42 +280,43 @@ rgb_ycc_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
 */

 METHODDEF(void)
-rgb_gray_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
-                 JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows)
+rgb_gray_convert (j_compress_ptr cinfo,
+                  JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+                  JDIMENSION output_row, int num_rows)
 {
  switch (cinfo->in_color_space) {
-  case JCS_EXT_RGB:
-    extrgb_gray_convert_internal(cinfo, input_buf, output_buf, output_row,
-                                 num_rows);
-    break;
-  case JCS_EXT_RGBX:
-  case JCS_EXT_RGBA:
-    extrgbx_gray_convert_internal(cinfo, input_buf, output_buf, output_row,
-                                  num_rows);
-    break;
-  case JCS_EXT_BGR:
-    extbgr_gray_convert_internal(cinfo, input_buf, output_buf, output_row,
-                                 num_rows);
-    break;
-  case JCS_EXT_BGRX:
-  case JCS_EXT_BGRA:
-    extbgrx_gray_convert_internal(cinfo, input_buf, output_buf, output_row,
-                                  num_rows);
-    break;
-  case JCS_EXT_XBGR:
-  case JCS_EXT_ABGR:
-    extxbgr_gray_convert_internal(cinfo, input_buf, output_buf, output_row,
-                                  num_rows);
-    break;
-  case JCS_EXT_XRGB:
-  case JCS_EXT_ARGB:
-    extxrgb_gray_convert_internal(cinfo, input_buf, output_buf, output_row,
-                                  num_rows);
-    break;
-  default:
-    rgb_gray_convert_internal(cinfo, input_buf, output_buf, output_row,
-                              num_rows);
-    break;
+    case JCS_EXT_RGB:
+      extrgb_gray_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                   num_rows);
+      break;
+    case JCS_EXT_RGBX:
+    case JCS_EXT_RGBA:
+      extrgbx_gray_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                    num_rows);
+      break;
+    case JCS_EXT_BGR:
+      extbgr_gray_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                   num_rows);
+      break;
+    case JCS_EXT_BGRX:
+    case JCS_EXT_BGRA:
+      extbgrx_gray_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                    num_rows);
+      break;
+    case JCS_EXT_XBGR:
+    case JCS_EXT_ABGR:
+      extxbgr_gray_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                    num_rows);
+      break;
+    case JCS_EXT_XRGB:
+    case JCS_EXT_ARGB:
+      extxrgb_gray_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                    num_rows);
+      break;
+    default:
+      rgb_gray_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                num_rows);
+      break;
  }
 }

@@ -324,42 +326,43 @@ rgb_gray_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
 */

 METHODDEF(void)
-rgb_rgb_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
-                JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows)
+rgb_rgb_convert (j_compress_ptr cinfo,
+                  JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+                  JDIMENSION output_row, int num_rows)
 {
  switch (cinfo->in_color_space) {
-  case JCS_EXT_RGB:
-    extrgb_rgb_convert_internal(cinfo, input_buf, output_buf, output_row,
-                                num_rows);
-    break;
-  case JCS_EXT_RGBX:
-  case JCS_EXT_RGBA:
-    extrgbx_rgb_convert_internal(cinfo, input_buf, output_buf, output_row,
-                                 num_rows);
-    break;
-  case JCS_EXT_BGR:
-    extbgr_rgb_convert_internal(cinfo, input_buf, output_buf, output_row,
-                                num_rows);
-    break;
-  case JCS_EXT_BGRX:
-  case JCS_EXT_BGRA:
-    extbgrx_rgb_convert_internal(cinfo, input_buf, output_buf, output_row,
-                                 num_rows);
-    break;
-  case JCS_EXT_XBGR:
-  case JCS_EXT_ABGR:
-    extxbgr_rgb_convert_internal(cinfo, input_buf, output_buf, output_row,
-                                 num_rows);
-    break;
-  case JCS_EXT_XRGB:
-  case JCS_EXT_ARGB:
-    extxrgb_rgb_convert_internal(cinfo, input_buf, output_buf, output_row,
-                                 num_rows);
-    break;
-  default:
-    rgb_rgb_convert_internal(cinfo, input_buf, output_buf, output_row,
-                             num_rows);
-    break;
+    case JCS_EXT_RGB:
+      extrgb_rgb_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                  num_rows);
+      break;
+    case JCS_EXT_RGBX:
+    case JCS_EXT_RGBA:
+      extrgbx_rgb_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                   num_rows);
+      break;
+    case JCS_EXT_BGR:
+      extbgr_rgb_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                  num_rows);
+      break;
+    case JCS_EXT_BGRX:
+    case JCS_EXT_BGRA:
+      extbgrx_rgb_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                   num_rows);
+      break;
+    case JCS_EXT_XBGR:
+    case JCS_EXT_ABGR:
+      extxbgr_rgb_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                   num_rows);
+      break;
+    case JCS_EXT_XRGB:
+    case JCS_EXT_ARGB:
+      extxrgb_rgb_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                   num_rows);
+      break;
+    default:
+      rgb_rgb_convert_internal(cinfo, input_buf, output_buf, output_row,
+                               num_rows);
+      break;
  }
 }

@@ -373,10 +376,11 @@ rgb_rgb_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
 */

 METHODDEF(void)
-cmyk_ycck_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
-                  JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows)
+cmyk_ycck_convert (j_compress_ptr cinfo,
+                   JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+                   JDIMENSION output_row, int num_rows)
 {
-  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
  register int r, g, b;
  register JLONG *ctab = cconvert->rgb_ycc_tab;
  register JSAMPROW inptr;
@@ -392,11 +396,11 @@ cmyk_ycck_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
    outptr3 = output_buf[3][output_row];
    output_row++;
    for (col = 0; col < num_cols; col++) {
-      r = MAXJSAMPLE - inptr[0];
-      g = MAXJSAMPLE - inptr[1];
-      b = MAXJSAMPLE - inptr[2];
+      r = MAXJSAMPLE - GETJSAMPLE(inptr[0]);
+      g = MAXJSAMPLE - GETJSAMPLE(inptr[1]);
+      b = MAXJSAMPLE - GETJSAMPLE(inptr[2]);
      /* K passes through as-is */
-      outptr3[col] = inptr[3];
+      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.
@@ -404,14 +408,17 @@ cmyk_ycck_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
       * need the general RIGHT_SHIFT macro.
       */
      /* Y */
-      outptr0[col] = (JSAMPLE)((ctab[r + R_Y_OFF] + ctab[g + G_Y_OFF] +
-                                ctab[b + B_Y_OFF]) >> SCALEBITS);
+      outptr0[col] = (JSAMPLE)
+                ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+                 >> SCALEBITS);
      /* Cb */
-      outptr1[col] = (JSAMPLE)((ctab[r + R_CB_OFF] + ctab[g + G_CB_OFF] +
-                                ctab[b + B_CB_OFF]) >> SCALEBITS);
+      outptr1[col] = (JSAMPLE)
+                ((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
+                 >> SCALEBITS);
      /* Cr */
-      outptr2[col] = (JSAMPLE)((ctab[r + R_CR_OFF] + ctab[g + G_CR_OFF] +
-                                ctab[b + B_CR_OFF]) >> SCALEBITS);
+      outptr2[col] = (JSAMPLE)
+                ((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
+                 >> SCALEBITS);
    }
  }
 }
@@ -424,8 +431,9 @@ cmyk_ycck_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
 */

 METHODDEF(void)
-grayscale_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
-                  JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows)
+grayscale_convert (j_compress_ptr cinfo,
+                   JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+                   JDIMENSION output_row, int num_rows)
 {
  register JSAMPROW inptr;
  register JSAMPROW outptr;
@@ -438,7 +446,7 @@ grayscale_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
    outptr = output_buf[0][output_row];
    output_row++;
    for (col = 0; col < num_cols; col++) {
-      outptr[col] = inptr[0];
+      outptr[col] = inptr[0];   /* don't need GETJSAMPLE() here */
      inptr += instride;
    }
  }
@@ -452,8 +460,9 @@ grayscale_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
 */

 METHODDEF(void)
-null_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
-             JDIMENSION output_row, int num_rows)
+null_convert (j_compress_ptr cinfo,
+              JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+              JDIMENSION output_row, int num_rows)
 {
  register JSAMPROW inptr;
  register JSAMPROW outptr, outptr0, outptr1, outptr2, outptr3;
@@ -497,7 +506,7 @@ null_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
        inptr = *input_buf;
        outptr = output_buf[ci][output_row];
        for (col = 0; col < num_cols; col++) {
-          outptr[col] = inptr[ci];
+          outptr[col] = inptr[ci]; /* don't need GETJSAMPLE() here */
          inptr += nc;
        }
      }
@@ -513,7 +522,7 @@ null_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
 */

 METHODDEF(void)
-null_method(j_compress_ptr cinfo)
+null_method (j_compress_ptr cinfo)
 {
  /* no work needed */
 }
@@ -524,14 +533,14 @@ null_method(j_compress_ptr cinfo)
 */

 GLOBAL(void)
-jinit_color_converter(j_compress_ptr cinfo)
+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,
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                sizeof(my_color_converter));
-  cinfo->cconvert = (struct jpeg_color_converter *)cconvert;
+  cinfo->cconvert = (struct jpeg_color_converter *) cconvert;
  /* set start_pass to null method until we find out differently */
  cconvert->pub.start_pass = null_method;

@@ -41,7 +41,7 @@ typedef void (*float_quantize_method_ptr) (JCOEFPTR coef_block,
                                           FAST_FLOAT *divisors,
                                           FAST_FLOAT *workspace);

-METHODDEF(void) quantize(JCOEFPTR, DCTELEM *, DCTELEM *);
+METHODDEF(void) quantize (JCOEFPTR, DCTELEM *, DCTELEM *);

 typedef struct {
  struct jpeg_forward_dct pub;  /* public fields */
@@ -80,7 +80,7 @@ typedef my_fdct_controller *my_fdct_ptr;
 */

 LOCAL(int)
-flss(UINT16 val)
+flss (UINT16 val)
 {
  int bit;

@@ -170,7 +170,7 @@ flss(UINT16 val)
 */

 LOCAL(int)
-compute_reciprocal(UINT16 divisor, DCTELEM *dtbl)
+compute_reciprocal (UINT16 divisor, DCTELEM *dtbl)
 {
  UDCTELEM2 fq, fr;
  UDCTELEM c;
@@ -182,10 +182,10 @@ compute_reciprocal(UINT16 divisor, DCTELEM *dtbl)
     * identity function.  Since only the C quantization algorithm is used in
     * these cases, the scale value is irrelevant.
     */
-    dtbl[DCTSIZE2 * 0] = (DCTELEM)1;                        /* reciprocal */
-    dtbl[DCTSIZE2 * 1] = (DCTELEM)0;                        /* correction */
-    dtbl[DCTSIZE2 * 2] = (DCTELEM)1;                        /* scale */
-    dtbl[DCTSIZE2 * 3] = -(DCTELEM)(sizeof(DCTELEM) * 8);   /* shift */
+    dtbl[DCTSIZE2 * 0] = (DCTELEM) 1;                       /* reciprocal */
+    dtbl[DCTSIZE2 * 1] = (DCTELEM) 0;                       /* correction */
+    dtbl[DCTSIZE2 * 2] = (DCTELEM) 1;                       /* scale */
+    dtbl[DCTSIZE2 * 3] = -(DCTELEM) (sizeof(DCTELEM) * 8);  /* shift */
    return 0;
  }

@@ -195,26 +195,26 @@ compute_reciprocal(UINT16 divisor, DCTELEM *dtbl)
  fq = ((UDCTELEM2)1 << r) / divisor;
  fr = ((UDCTELEM2)1 << r) % divisor;

-  c = divisor / 2;                      /* for rounding */
+  c = divisor / 2; /* for rounding */

-  if (fr == 0) {                        /* divisor is power of two */
+  if (fr == 0) { /* divisor is power of two */
    /* fq will be one bit too large to fit in DCTELEM, so adjust */
    fq >>= 1;
    r--;
-  } else if (fr <= (divisor / 2U)) {    /* fractional part is < 0.5 */
+  } else if (fr <= (divisor / 2U)) { /* fractional part is < 0.5 */
    c++;
-  } else {                              /* fractional part is > 0.5 */
+  } else { /* fractional part is > 0.5 */
    fq++;
  }

-  dtbl[DCTSIZE2 * 0] = (DCTELEM)fq;     /* reciprocal */
-  dtbl[DCTSIZE2 * 1] = (DCTELEM)c;      /* correction + roundfactor */
+  dtbl[DCTSIZE2 * 0] = (DCTELEM) fq;      /* reciprocal */
+  dtbl[DCTSIZE2 * 1] = (DCTELEM) c;       /* correction + roundfactor */
 #ifdef WITH_SIMD
-  dtbl[DCTSIZE2 * 2] = (DCTELEM)(1 << (sizeof(DCTELEM) * 8 * 2 - r)); /* scale */
+  dtbl[DCTSIZE2 * 2] = (DCTELEM) (1 << (sizeof(DCTELEM)*8*2 - r));  /* scale */
 #else
  dtbl[DCTSIZE2 * 2] = 1;
 #endif
-  dtbl[DCTSIZE2 * 3] = (DCTELEM)r - sizeof(DCTELEM) * 8; /* shift */
+  dtbl[DCTSIZE2 * 3] = (DCTELEM) r - sizeof(DCTELEM)*8; /* shift */

  if (r <= 16) return 0;
  else return 1;
@@ -233,9 +233,9 @@ compute_reciprocal(UINT16 divisor, DCTELEM *dtbl)
 */

 METHODDEF(void)
-start_pass_fdctmgr(j_compress_ptr cinfo)
+start_pass_fdctmgr (j_compress_ptr cinfo)
 {
-  my_fdct_ptr fdct = (my_fdct_ptr)cinfo->fdct;
+  my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
  int ci, qtblno, i;
  jpeg_component_info *compptr;
  JQUANT_TBL *qtbl;
@@ -259,7 +259,7 @@ start_pass_fdctmgr(j_compress_ptr cinfo)
       */
      if (fdct->divisors[qtblno] == NULL) {
        fdct->divisors[qtblno] = (DCTELEM *)
-          (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+          (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                      (DCTSIZE2 * 4) * sizeof(DCTELEM));
      }
      dtbl = fdct->divisors[qtblno];
@@ -269,7 +269,7 @@ start_pass_fdctmgr(j_compress_ptr cinfo)
            fdct->quantize == jsimd_quantize)
          fdct->quantize = quantize;
 #else
-        dtbl[i] = ((DCTELEM)qtbl->quantval[i]) << 3;
+        dtbl[i] = ((DCTELEM) qtbl->quantval[i]) << 3;
 #endif
      }
      break;
@@ -283,7 +283,7 @@ start_pass_fdctmgr(j_compress_ptr cinfo)
         *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
         * We apply a further scale factor of 8.
         */
-#define CONST_BITS  14
+#define CONST_BITS 14
        static const INT16 aanscales[DCTSIZE2] = {
          /* precomputed values scaled up by 14 bits */
          16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
@@ -299,23 +299,23 @@ start_pass_fdctmgr(j_compress_ptr cinfo)

        if (fdct->divisors[qtblno] == NULL) {
          fdct->divisors[qtblno] = (DCTELEM *)
-            (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+            (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                        (DCTSIZE2 * 4) * sizeof(DCTELEM));
        }
        dtbl = fdct->divisors[qtblno];
        for (i = 0; i < DCTSIZE2; i++) {
 #if BITS_IN_JSAMPLE == 8
          if (!compute_reciprocal(
-                DESCALE(MULTIPLY16V16((JLONG)qtbl->quantval[i],
-                                      (JLONG)aanscales[i]),
-                        CONST_BITS - 3), &dtbl[i]) &&
+                DESCALE(MULTIPLY16V16((JLONG) qtbl->quantval[i],
+                                      (JLONG) aanscales[i]),
+                        CONST_BITS-3), &dtbl[i]) &&
              fdct->quantize == jsimd_quantize)
            fdct->quantize = quantize;
 #else
-          dtbl[i] = (DCTELEM)
-            DESCALE(MULTIPLY16V16((JLONG)qtbl->quantval[i],
-                                  (JLONG)aanscales[i]),
-                    CONST_BITS - 3);
+           dtbl[i] = (DCTELEM)
+             DESCALE(MULTIPLY16V16((JLONG) qtbl->quantval[i],
+                                   (JLONG) aanscales[i]),
+                     CONST_BITS-3);
 #endif
        }
      }
@@ -341,7 +341,7 @@ start_pass_fdctmgr(j_compress_ptr cinfo)

        if (fdct->float_divisors[qtblno] == NULL) {
          fdct->float_divisors[qtblno] = (FAST_FLOAT *)
-            (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+            (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                        DCTSIZE2 * sizeof(FAST_FLOAT));
        }
        fdtbl = fdct->float_divisors[qtblno];
@@ -349,7 +349,7 @@ start_pass_fdctmgr(j_compress_ptr cinfo)
        for (row = 0; row < DCTSIZE; row++) {
          for (col = 0; col < DCTSIZE; col++) {
            fdtbl[i] = (FAST_FLOAT)
-              (1.0 / (((double)qtbl->quantval[i] *
+              (1.0 / (((double) qtbl->quantval[i] *
                       aanscalefactor[row] * aanscalefactor[col] * 8.0)));
            i++;
          }
@@ -370,7 +370,7 @@ start_pass_fdctmgr(j_compress_ptr cinfo)
 */

 METHODDEF(void)
-convsamp(JSAMPARRAY sample_data, JDIMENSION start_col, DCTELEM *workspace)
+convsamp (JSAMPARRAY sample_data, JDIMENSION start_col, DCTELEM *workspace)
 {
  register DCTELEM *workspaceptr;
  register JSAMPROW elemptr;
@@ -381,19 +381,19 @@ convsamp(JSAMPARRAY sample_data, JDIMENSION start_col, DCTELEM *workspace)
    elemptr = sample_data[elemr] + start_col;

 #if DCTSIZE == 8                /* unroll the inner loop */
-    *workspaceptr++ = (*elemptr++) - CENTERJSAMPLE;
-    *workspaceptr++ = (*elemptr++) - CENTERJSAMPLE;
-    *workspaceptr++ = (*elemptr++) - CENTERJSAMPLE;
-    *workspaceptr++ = (*elemptr++) - CENTERJSAMPLE;
-    *workspaceptr++ = (*elemptr++) - CENTERJSAMPLE;
-    *workspaceptr++ = (*elemptr++) - CENTERJSAMPLE;
-    *workspaceptr++ = (*elemptr++) - CENTERJSAMPLE;
-    *workspaceptr++ = (*elemptr++) - CENTERJSAMPLE;
+    *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+    *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+    *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+    *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+    *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+    *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+    *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+    *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
 #else
    {
      register int elemc;
      for (elemc = DCTSIZE; elemc > 0; elemc--)
-        *workspaceptr++ = (*elemptr++) - CENTERJSAMPLE;
+        *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
    }
 #endif
  }
@@ -405,7 +405,7 @@ convsamp(JSAMPARRAY sample_data, JDIMENSION start_col, DCTELEM *workspace)
 */

 METHODDEF(void)
-quantize(JCOEFPTR coef_block, DCTELEM *divisors, DCTELEM *workspace)
+quantize (JCOEFPTR coef_block, DCTELEM *divisors, DCTELEM *workspace)
 {
  int i;
  DCTELEM temp;
@@ -426,15 +426,15 @@ quantize(JCOEFPTR coef_block, DCTELEM *divisors, DCTELEM *workspace)
    if (temp < 0) {
      temp = -temp;
      product = (UDCTELEM2)(temp + corr) * recip;
-      product >>= shift + sizeof(DCTELEM) * 8;
+      product >>= shift + sizeof(DCTELEM)*8;
      temp = (DCTELEM)product;
      temp = -temp;
    } else {
      product = (UDCTELEM2)(temp + corr) * recip;
-      product >>= shift + sizeof(DCTELEM) * 8;
+      product >>= shift + sizeof(DCTELEM)*8;
      temp = (DCTELEM)product;
    }
-    output_ptr[i] = (JCOEF)temp;
+    output_ptr[i] = (JCOEF) temp;
  }

 #else
@@ -457,20 +457,20 @@ quantize(JCOEFPTR coef_block, DCTELEM *divisors, DCTELEM *workspace)
     * If your machine's division is fast enough, define FAST_DIVIDE.
     */
 #ifdef FAST_DIVIDE
-#define DIVIDE_BY(a, b)  a /= b
+#define DIVIDE_BY(a,b)  a /= b
 #else
-#define DIVIDE_BY(a, b)  if (a >= b) a /= b;  else a = 0
+#define DIVIDE_BY(a,b)  if (a >= b) a /= b; else a = 0
 #endif
    if (temp < 0) {
      temp = -temp;
-      temp += qval >> 1;        /* for rounding */
+      temp += qval>>1;  /* for rounding */
      DIVIDE_BY(temp, qval);
      temp = -temp;
    } else {
-      temp += qval >> 1;        /* for rounding */
+      temp += qval>>1;  /* for rounding */
      DIVIDE_BY(temp, qval);
    }
-    output_ptr[i] = (JCOEF)temp;
+    output_ptr[i] = (JCOEF) temp;
  }

 #endif
@@ -487,13 +487,14 @@ quantize(JCOEFPTR coef_block, DCTELEM *divisors, DCTELEM *workspace)
 */

 METHODDEF(void)
-forward_DCT(j_compress_ptr cinfo, jpeg_component_info *compptr,
-            JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
-            JDIMENSION start_row, JDIMENSION start_col, JDIMENSION num_blocks)
+forward_DCT (j_compress_ptr cinfo, jpeg_component_info *compptr,
+             JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
+             JDIMENSION start_row, JDIMENSION start_col,
+             JDIMENSION num_blocks)
 /* This version is used for integer DCT implementations. */
 {
  /* This routine is heavily used, so it's worth coding it tightly. */
-  my_fdct_ptr fdct = (my_fdct_ptr)cinfo->fdct;
+  my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
  DCTELEM *divisors = fdct->divisors[compptr->quant_tbl_no];
  DCTELEM *workspace;
  JDIMENSION bi;
@@ -521,9 +522,9 @@ forward_DCT(j_compress_ptr cinfo, jpeg_component_info *compptr,

 #ifdef DCT_FLOAT_SUPPORTED

+
 METHODDEF(void)
-convsamp_float(JSAMPARRAY sample_data, JDIMENSION start_col,
-               FAST_FLOAT *workspace)
+convsamp_float (JSAMPARRAY sample_data, JDIMENSION start_col, FAST_FLOAT *workspace)
 {
  register FAST_FLOAT *workspaceptr;
  register JSAMPROW elemptr;
@@ -533,19 +534,20 @@ convsamp_float(JSAMPARRAY sample_data, JDIMENSION start_col,
  for (elemr = 0; elemr < DCTSIZE; elemr++) {
    elemptr = sample_data[elemr] + start_col;
 #if DCTSIZE == 8                /* unroll the inner loop */
-    *workspaceptr++ = (FAST_FLOAT)((*elemptr++) - CENTERJSAMPLE);
-    *workspaceptr++ = (FAST_FLOAT)((*elemptr++) - CENTERJSAMPLE);
-    *workspaceptr++ = (FAST_FLOAT)((*elemptr++) - CENTERJSAMPLE);
-    *workspaceptr++ = (FAST_FLOAT)((*elemptr++) - CENTERJSAMPLE);
-    *workspaceptr++ = (FAST_FLOAT)((*elemptr++) - CENTERJSAMPLE);
-    *workspaceptr++ = (FAST_FLOAT)((*elemptr++) - CENTERJSAMPLE);
-    *workspaceptr++ = (FAST_FLOAT)((*elemptr++) - CENTERJSAMPLE);
-    *workspaceptr++ = (FAST_FLOAT)((*elemptr++) - CENTERJSAMPLE);
+    *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+    *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+    *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+    *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+    *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+    *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+    *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+    *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
 #else
    {
      register int elemc;
      for (elemc = DCTSIZE; elemc > 0; elemc--)
-        *workspaceptr++ = (FAST_FLOAT)((*elemptr++) - CENTERJSAMPLE);
+        *workspaceptr++ = (FAST_FLOAT)
+                          (GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
    }
 #endif
  }
@@ -553,8 +555,7 @@ convsamp_float(JSAMPARRAY sample_data, JDIMENSION start_col,


 METHODDEF(void)
-quantize_float(JCOEFPTR coef_block, FAST_FLOAT *divisors,
-               FAST_FLOAT *workspace)
+quantize_float (JCOEFPTR coef_block, FAST_FLOAT *divisors, FAST_FLOAT *workspace)
 {
  register FAST_FLOAT temp;
  register int i;
@@ -570,20 +571,20 @@ quantize_float(JCOEFPTR coef_block, FAST_FLOAT *divisors,
     * The maximum coefficient size is +-16K (for 12-bit data), so this
     * code should work for either 16-bit or 32-bit ints.
     */
-    output_ptr[i] = (JCOEF)((int)(temp + (FAST_FLOAT)16384.5) - 16384);
+    output_ptr[i] = (JCOEF) ((int) (temp + (FAST_FLOAT) 16384.5) - 16384);
  }
 }


 METHODDEF(void)
-forward_DCT_float(j_compress_ptr cinfo, jpeg_component_info *compptr,
-                  JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
-                  JDIMENSION start_row, JDIMENSION start_col,
-                  JDIMENSION num_blocks)
+forward_DCT_float (j_compress_ptr cinfo, jpeg_component_info *compptr,
+                   JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
+                   JDIMENSION start_row, JDIMENSION start_col,
+                   JDIMENSION num_blocks)
 /* This version is used for floating-point DCT implementations. */
 {
  /* This routine is heavily used, so it's worth coding it tightly. */
-  my_fdct_ptr fdct = (my_fdct_ptr)cinfo->fdct;
+  my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
  FAST_FLOAT *divisors = fdct->float_divisors[compptr->quant_tbl_no];
  FAST_FLOAT *workspace;
  JDIMENSION bi;
@@ -617,15 +618,15 @@ forward_DCT_float(j_compress_ptr cinfo, jpeg_component_info *compptr,
 */

 GLOBAL(void)
-jinit_forward_dct(j_compress_ptr cinfo)
+jinit_forward_dct (j_compress_ptr cinfo)
 {
  my_fdct_ptr fdct;
  int i;

  fdct = (my_fdct_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                sizeof(my_fdct_controller));
-  cinfo->fdct = (struct jpeg_forward_dct *)fdct;
+  cinfo->fdct = (struct jpeg_forward_dct *) fdct;
  fdct->pub.start_pass = start_pass_fdctmgr;

  /* First determine the DCT... */
@@ -702,12 +703,12 @@ jinit_forward_dct(j_compress_ptr cinfo)
 #ifdef DCT_FLOAT_SUPPORTED
  if (cinfo->dct_method == JDCT_FLOAT)
    fdct->float_workspace = (FAST_FLOAT *)
-      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                  sizeof(FAST_FLOAT) * DCTSIZE2);
  else
 #endif
    fdct->workspace = (DCTELEM *)
-      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                  sizeof(DCTELEM) * DCTSIZE2);

  /* Mark divisor tables unallocated */
@@ -20,9 +20,9 @@
 */

 #if BITS_IN_JSAMPLE == 8
-#define MAX_COEF_BITS  10
+#define MAX_COEF_BITS 10
 #else
-#define MAX_COEF_BITS  14
+#define MAX_COEF_BITS 14
 #endif

 /* Derived data constructed for each Huffman table */
@@ -34,9 +34,10 @@ typedef struct {
 } c_derived_tbl;

 /* Expand a Huffman table definition into the derived format */
-EXTERN(void) jpeg_make_c_derived_tbl(j_compress_ptr cinfo, boolean isDC,
-                                     int tblno, c_derived_tbl **pdtbl);
+EXTERN(void) jpeg_make_c_derived_tbl
+        (j_compress_ptr cinfo, boolean isDC, int tblno,
+         c_derived_tbl ** pdtbl);

 /* Generate an optimal table definition given the specified counts */
-EXTERN(void) jpeg_gen_optimal_table(j_compress_ptr cinfo, JHUFF_TBL *htbl,
-                                    long freq[]);
+EXTERN(void) jpeg_gen_optimal_table
+        (j_compress_ptr cinfo, JHUFF_TBL *htbl, long freq[]);
@@ -1,105 +0,0 @@
-/*
- * jcicc.c
- *
- * Copyright (C) 1997-1998, Thomas G. Lane, Todd Newman.
- * Copyright (C) 2017, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file provides code to write International Color Consortium (ICC) device
- * profiles embedded in JFIF JPEG image files.  The ICC has defined a standard
- * for including such data in JPEG "APP2" markers.  The code given here does
- * not know anything about the internal structure of the ICC profile data; it
- * just knows how to embed the profile data in a JPEG file while writing it.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jerror.h"
-
-
-/*
- * Since an ICC profile can be larger than the maximum size of a JPEG marker
- * (64K), we need provisions to split it into multiple markers.  The format
- * defined by the ICC specifies one or more APP2 markers containing the
- * following data:
- *      Identifying string      ASCII "ICC_PROFILE\0"  (12 bytes)
- *      Marker sequence number  1 for first APP2, 2 for next, etc (1 byte)
- *      Number of markers       Total number of APP2's used (1 byte)
- *      Profile data            (remainder of APP2 data)
- * Decoders should use the marker sequence numbers to reassemble the profile,
- * rather than assuming that the APP2 markers appear in the correct sequence.
- */
-
-#define ICC_MARKER  (JPEG_APP0 + 2)     /* JPEG marker code for ICC */
-#define ICC_OVERHEAD_LEN  14            /* size of non-profile data in APP2 */
-#define MAX_BYTES_IN_MARKER  65533      /* maximum data len of a JPEG marker */
-#define MAX_DATA_BYTES_IN_MARKER  (MAX_BYTES_IN_MARKER - ICC_OVERHEAD_LEN)
-
-
-/*
- * This routine writes the given ICC profile data into a JPEG file.  It *must*
- * be called AFTER calling jpeg_start_compress() and BEFORE the first call to
- * jpeg_write_scanlines().  (This ordering ensures that the APP2 marker(s) will
- * appear after the SOI and JFIF or Adobe markers, but before all else.)
- */
-
-GLOBAL(void)
-jpeg_write_icc_profile(j_compress_ptr cinfo, const JOCTET *icc_data_ptr,
-                       unsigned int icc_data_len)
-{
-  unsigned int num_markers;     /* total number of markers we'll write */
-  int cur_marker = 1;           /* per spec, counting starts at 1 */
-  unsigned int length;          /* number of bytes to write in this marker */
-
-  if (icc_data_ptr == NULL || icc_data_len == 0)
-    ERREXIT(cinfo, JERR_BUFFER_SIZE);
-  if (cinfo->global_state < CSTATE_SCANNING)
-    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
-
-  /* Calculate the number of markers we'll need, rounding up of course */
-  num_markers = icc_data_len / MAX_DATA_BYTES_IN_MARKER;
-  if (num_markers * MAX_DATA_BYTES_IN_MARKER != icc_data_len)
-    num_markers++;
-
-  while (icc_data_len > 0) {
-    /* length of profile to put in this marker */
-    length = icc_data_len;
-    if (length > MAX_DATA_BYTES_IN_MARKER)
-      length = MAX_DATA_BYTES_IN_MARKER;
-    icc_data_len -= length;
-
-    /* Write the JPEG marker header (APP2 code and marker length) */
-    jpeg_write_m_header(cinfo, ICC_MARKER,
-                        (unsigned int)(length + ICC_OVERHEAD_LEN));
-
-    /* Write the marker identifying string "ICC_PROFILE" (null-terminated).  We
-     * code it in this less-than-transparent way so that the code works even if
-     * the local character set is not ASCII.
-     */
-    jpeg_write_m_byte(cinfo, 0x49);
-    jpeg_write_m_byte(cinfo, 0x43);
-    jpeg_write_m_byte(cinfo, 0x43);
-    jpeg_write_m_byte(cinfo, 0x5F);
-    jpeg_write_m_byte(cinfo, 0x50);
-    jpeg_write_m_byte(cinfo, 0x52);
-    jpeg_write_m_byte(cinfo, 0x4F);
-    jpeg_write_m_byte(cinfo, 0x46);
-    jpeg_write_m_byte(cinfo, 0x49);
-    jpeg_write_m_byte(cinfo, 0x4C);
-    jpeg_write_m_byte(cinfo, 0x45);
-    jpeg_write_m_byte(cinfo, 0x0);
-
-    /* Add the sequencing info */
-    jpeg_write_m_byte(cinfo, cur_marker);
-    jpeg_write_m_byte(cinfo, (int)num_markers);
-
-    /* Add the profile data */
-    while (length--) {
-      jpeg_write_m_byte(cinfo, *icc_data_ptr);
-      icc_data_ptr++;
-    }
-    cur_marker++;
-  }
-}
@@ -1,10 +1,8 @@
 /*
 * jcinit.c
 *
- * This file was part of the Independent JPEG Group's software:
 * Copyright (C) 1991-1997, Thomas G. Lane.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2020, D. R. Commander.
+ * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
 *
@@ -21,7 +19,6 @@
 #define JPEG_INTERNALS
 #include "jinclude.h"
 #include "jpeglib.h"
-#include "jpegcomp.h"


 /*
@@ -31,13 +28,13 @@
 */

 GLOBAL(void)
-jinit_compress_master(j_compress_ptr cinfo)
+jinit_compress_master (j_compress_ptr cinfo)
 {
  /* Initialize master control (includes parameter checking/processing) */
  jinit_c_master_control(cinfo, FALSE /* full compression */);

  /* Preprocessing */
-  if (!cinfo->raw_data_in) {
+  if (! cinfo->raw_data_in) {
    jinit_color_converter(cinfo);
    jinit_downsampler(cinfo);
    jinit_c_prep_controller(cinfo, FALSE /* never need full buffer here */);
@@ -63,14 +60,14 @@ jinit_compress_master(j_compress_ptr cinfo)
  }

  /* Need a full-image coefficient buffer in any multi-pass mode. */
-  jinit_c_coef_controller(cinfo, (boolean)(cinfo->num_scans > 1 ||
-                                           cinfo->optimize_coding));
+  jinit_c_coef_controller(cinfo,
+                (boolean) (cinfo->num_scans > 1 || cinfo->optimize_coding));
  jinit_c_main_controller(cinfo, FALSE /* never need full buffer here */);

  jinit_marker_writer(cinfo);

  /* We can now tell the memory manager to allocate virtual arrays. */
-  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr)cinfo);
+  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);

  /* Write the datastream header (SOI) immediately.
   * Frame and scan headers are postponed till later.
@@ -39,10 +39,9 @@ typedef my_main_controller *my_main_ptr;


 /* Forward declarations */
-METHODDEF(void) process_data_simple_main(j_compress_ptr cinfo,
-                                         JSAMPARRAY input_buf,
-                                         JDIMENSION *in_row_ctr,
-                                         JDIMENSION in_rows_avail);
+METHODDEF(void) process_data_simple_main
+        (j_compress_ptr cinfo, JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+         JDIMENSION in_rows_avail);


 /*
@@ -50,9 +49,9 @@ METHODDEF(void) process_data_simple_main(j_compress_ptr cinfo,
 */

 METHODDEF(void)
-start_pass_main(j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+start_pass_main (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
 {
-  my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
+  my_main_ptr main_ptr = (my_main_ptr) cinfo->main;

  /* Do nothing in raw-data mode. */
  if (cinfo->raw_data_in)
@@ -76,18 +75,19 @@ start_pass_main(j_compress_ptr cinfo, J_BUF_MODE pass_mode)
 */

 METHODDEF(void)
-process_data_simple_main(j_compress_ptr cinfo, JSAMPARRAY input_buf,
-                         JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail)
+process_data_simple_main (j_compress_ptr cinfo,
+                          JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+                          JDIMENSION in_rows_avail)
 {
-  my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
+  my_main_ptr main_ptr = (my_main_ptr) cinfo->main;

  while (main_ptr->cur_iMCU_row < cinfo->total_iMCU_rows) {
    /* Read input data if we haven't filled the main buffer yet */
    if (main_ptr->rowgroup_ctr < DCTSIZE)
-      (*cinfo->prep->pre_process_data) (cinfo, input_buf, in_row_ctr,
-                                        in_rows_avail, main_ptr->buffer,
-                                        &main_ptr->rowgroup_ctr,
-                                        (JDIMENSION)DCTSIZE);
+      (*cinfo->prep->pre_process_data) (cinfo,
+                                        input_buf, in_row_ctr, in_rows_avail,
+                                        main_ptr->buffer, &main_ptr->rowgroup_ctr,
+                                        (JDIMENSION) DCTSIZE);

    /* If we don't have a full iMCU row buffered, return to application for
     * more data.  Note that preprocessor will always pad to fill the iMCU row
@@ -97,14 +97,14 @@ process_data_simple_main(j_compress_ptr cinfo, JSAMPARRAY input_buf,
      return;

    /* Send the completed row to the compressor */
-    if (!(*cinfo->coef->compress_data) (cinfo, main_ptr->buffer)) {
+    if (! (*cinfo->coef->compress_data) (cinfo, main_ptr->buffer)) {
      /* If compressor did not consume the whole row, then we must need to
       * suspend processing and return to the application.  In this situation
       * we pretend we didn't yet consume the last input row; otherwise, if
       * it happened to be the last row of the image, the application would
       * think we were done.
       */
-      if (!main_ptr->suspended) {
+      if (! main_ptr->suspended) {
        (*in_row_ctr)--;
        main_ptr->suspended = TRUE;
      }
@@ -128,16 +128,16 @@ process_data_simple_main(j_compress_ptr cinfo, JSAMPARRAY input_buf,
 */

 GLOBAL(void)
-jinit_c_main_controller(j_compress_ptr cinfo, boolean need_full_buffer)
+jinit_c_main_controller (j_compress_ptr cinfo, boolean need_full_buffer)
 {
  my_main_ptr main_ptr;
  int ci;
  jpeg_component_info *compptr;

  main_ptr = (my_main_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                sizeof(my_main_controller));
-  cinfo->main = (struct jpeg_c_main_controller *)main_ptr;
+  cinfo->main = (struct jpeg_c_main_controller *) main_ptr;
  main_ptr->pub.start_pass = start_pass_main;

  /* We don't need to create a buffer in raw-data mode. */
@@ -154,9 +154,9 @@ jinit_c_main_controller(j_compress_ptr cinfo, boolean need_full_buffer)
    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
         ci++, compptr++) {
      main_ptr->buffer[ci] = (*cinfo->mem->alloc_sarray)
-        ((j_common_ptr)cinfo, JPOOL_IMAGE,
+        ((j_common_ptr) cinfo, JPOOL_IMAGE,
         compptr->width_in_blocks * DCTSIZE,
-         (JDIMENSION)(compptr->v_samp_factor * DCTSIZE));
+         (JDIMENSION) (compptr->v_samp_factor * DCTSIZE));
    }
  }
 }
@@ -110,30 +110,30 @@ typedef my_marker_writer *my_marker_ptr;
 */

 LOCAL(void)
-emit_byte(j_compress_ptr cinfo, int val)
+emit_byte (j_compress_ptr cinfo, int val)
 /* Emit a byte */
 {
  struct jpeg_destination_mgr *dest = cinfo->dest;

-  *(dest->next_output_byte)++ = (JOCTET)val;
+  *(dest->next_output_byte)++ = (JOCTET) val;
  if (--dest->free_in_buffer == 0) {
-    if (!(*dest->empty_output_buffer) (cinfo))
+    if (! (*dest->empty_output_buffer) (cinfo))
      ERREXIT(cinfo, JERR_CANT_SUSPEND);
  }
 }


 LOCAL(void)
-emit_marker(j_compress_ptr cinfo, JPEG_MARKER mark)
+emit_marker (j_compress_ptr cinfo, JPEG_MARKER mark)
 /* Emit a marker code */
 {
  emit_byte(cinfo, 0xFF);
-  emit_byte(cinfo, (int)mark);
+  emit_byte(cinfo, (int) mark);
 }


 LOCAL(void)
-emit_2bytes(j_compress_ptr cinfo, int value)
+emit_2bytes (j_compress_ptr cinfo, int value)
 /* Emit a 2-byte integer; these are always MSB first in JPEG files */
 {
  emit_byte(cinfo, (value >> 8) & 0xFF);
@@ -146,7 +146,7 @@ emit_2bytes(j_compress_ptr cinfo, int value)
 */

 LOCAL(int)
-emit_dqt(j_compress_ptr cinfo, int index)
+emit_dqt (j_compress_ptr cinfo, int index)
 /* Emit a DQT marker */
 /* Returns the precision used (0 = 8bits, 1 = 16bits) for baseline checking */
 {
@@ -163,19 +163,19 @@ emit_dqt(j_compress_ptr cinfo, int index)
      prec = 1;
  }

-  if (!qtbl->sent_table) {
+  if (! qtbl->sent_table) {
    emit_marker(cinfo, M_DQT);

-    emit_2bytes(cinfo, prec ? DCTSIZE2 * 2 + 1 + 2 : DCTSIZE2 + 1 + 2);
+    emit_2bytes(cinfo, prec ? DCTSIZE2*2 + 1 + 2 : DCTSIZE2 + 1 + 2);

-    emit_byte(cinfo, index + (prec << 4));
+    emit_byte(cinfo, index + (prec<<4));

    for (i = 0; i < DCTSIZE2; i++) {
      /* The table entries must be emitted in zigzag order. */
      unsigned int qval = qtbl->quantval[jpeg_natural_order[i]];
      if (prec)
-        emit_byte(cinfo, (int)(qval >> 8));
-      emit_byte(cinfo, (int)(qval & 0xFF));
+        emit_byte(cinfo, (int) (qval >> 8));
+      emit_byte(cinfo, (int) (qval & 0xFF));
    }

    qtbl->sent_table = TRUE;
@@ -186,7 +186,7 @@ emit_dqt(j_compress_ptr cinfo, int index)


 LOCAL(void)
-emit_dht(j_compress_ptr cinfo, int index, boolean is_ac)
+emit_dht (j_compress_ptr cinfo, int index, boolean is_ac)
 /* Emit a DHT marker */
 {
  JHUFF_TBL *htbl;
@@ -202,7 +202,7 @@ emit_dht(j_compress_ptr cinfo, int index, boolean is_ac)
  if (htbl == NULL)
    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, index);

-  if (!htbl->sent_table) {
+  if (! htbl->sent_table) {
    emit_marker(cinfo, M_DHT);

    length = 0;
@@ -224,7 +224,7 @@ emit_dht(j_compress_ptr cinfo, int index, boolean is_ac)


 LOCAL(void)
-emit_dac(j_compress_ptr cinfo)
+emit_dac (j_compress_ptr cinfo)
 /* Emit a DAC marker */
 /* Since the useful info is so small, we want to emit all the tables in */
 /* one DAC marker.  Therefore this routine does its own scan of the table. */
@@ -255,12 +255,12 @@ emit_dac(j_compress_ptr cinfo)
  if (length) {
    emit_marker(cinfo, M_DAC);

-    emit_2bytes(cinfo, length * 2 + 2);
+    emit_2bytes(cinfo, length*2 + 2);

    for (i = 0; i < NUM_ARITH_TBLS; i++) {
      if (dc_in_use[i]) {
        emit_byte(cinfo, i);
-        emit_byte(cinfo, cinfo->arith_dc_L[i] + (cinfo->arith_dc_U[i] << 4));
+        emit_byte(cinfo, cinfo->arith_dc_L[i] + (cinfo->arith_dc_U[i]<<4));
      }
      if (ac_in_use[i]) {
        emit_byte(cinfo, i + 0x10);
@@ -273,19 +273,19 @@ emit_dac(j_compress_ptr cinfo)


 LOCAL(void)
-emit_dri(j_compress_ptr cinfo)
+emit_dri (j_compress_ptr cinfo)
 /* Emit a DRI marker */
 {
  emit_marker(cinfo, M_DRI);

  emit_2bytes(cinfo, 4);        /* fixed length */

-  emit_2bytes(cinfo, (int)cinfo->restart_interval);
+  emit_2bytes(cinfo, (int) cinfo->restart_interval);
 }


 LOCAL(void)
-emit_sof(j_compress_ptr cinfo, JPEG_MARKER code)
+emit_sof (j_compress_ptr cinfo, JPEG_MARKER code)
 /* Emit a SOF marker */
 {
  int ci;
@@ -296,12 +296,13 @@ emit_sof(j_compress_ptr cinfo, JPEG_MARKER code)
  emit_2bytes(cinfo, 3 * cinfo->num_components + 2 + 5 + 1); /* length */

  /* Make sure image isn't bigger than SOF field can handle */
-  if ((long)cinfo->_jpeg_height > 65535L || (long)cinfo->_jpeg_width > 65535L)
-    ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int)65535);
+  if ((long) cinfo->_jpeg_height > 65535L ||
+      (long) cinfo->_jpeg_width > 65535L)
+    ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) 65535);

  emit_byte(cinfo, cinfo->data_precision);
-  emit_2bytes(cinfo, (int)cinfo->_jpeg_height);
-  emit_2bytes(cinfo, (int)cinfo->_jpeg_width);
+  emit_2bytes(cinfo, (int) cinfo->_jpeg_height);
+  emit_2bytes(cinfo, (int) cinfo->_jpeg_width);

  emit_byte(cinfo, cinfo->num_components);

@@ -315,7 +316,7 @@ emit_sof(j_compress_ptr cinfo, JPEG_MARKER code)


 LOCAL(void)
-emit_sos(j_compress_ptr cinfo)
+emit_sos (j_compress_ptr cinfo)
 /* Emit a SOS marker */
 {
  int i, td, ta;
@@ -350,7 +351,7 @@ emit_sos(j_compress_ptr cinfo)


 LOCAL(void)
-emit_jfif_app0(j_compress_ptr cinfo)
+emit_jfif_app0 (j_compress_ptr cinfo)
 /* Emit a JFIF-compliant APP0 marker */
 {
  /*
@@ -377,15 +378,15 @@ emit_jfif_app0(j_compress_ptr cinfo)
  emit_byte(cinfo, cinfo->JFIF_major_version); /* Version fields */
  emit_byte(cinfo, cinfo->JFIF_minor_version);
  emit_byte(cinfo, cinfo->density_unit); /* Pixel size information */
-  emit_2bytes(cinfo, (int)cinfo->X_density);
-  emit_2bytes(cinfo, (int)cinfo->Y_density);
+  emit_2bytes(cinfo, (int) cinfo->X_density);
+  emit_2bytes(cinfo, (int) cinfo->Y_density);
  emit_byte(cinfo, 0);          /* No thumbnail image */
  emit_byte(cinfo, 0);
 }


 LOCAL(void)
-emit_adobe_app14(j_compress_ptr cinfo)
+emit_adobe_app14 (j_compress_ptr cinfo)
 /* Emit an Adobe APP14 marker */
 {
  /*
@@ -439,19 +440,19 @@ emit_adobe_app14(j_compress_ptr cinfo)
 */

 METHODDEF(void)
-write_marker_header(j_compress_ptr cinfo, int marker, unsigned int datalen)
+write_marker_header (j_compress_ptr cinfo, int marker, unsigned int datalen)
 /* Emit an arbitrary marker header */
 {
-  if (datalen > (unsigned int)65533)            /* safety check */
+  if (datalen > (unsigned int) 65533)           /* safety check */
    ERREXIT(cinfo, JERR_BAD_LENGTH);

-  emit_marker(cinfo, (JPEG_MARKER)marker);
+  emit_marker(cinfo, (JPEG_MARKER) marker);

-  emit_2bytes(cinfo, (int)(datalen + 2));       /* total length */
+  emit_2bytes(cinfo, (int) (datalen + 2));      /* total length */
 }

 METHODDEF(void)
-write_marker_byte(j_compress_ptr cinfo, int val)
+write_marker_byte (j_compress_ptr cinfo, int val)
 /* Emit one byte of marker parameters following write_marker_header */
 {
  emit_byte(cinfo, val);
@@ -470,9 +471,9 @@ write_marker_byte(j_compress_ptr cinfo, int val)
 */

 METHODDEF(void)
-write_file_header(j_compress_ptr cinfo)
+write_file_header (j_compress_ptr cinfo)
 {
-  my_marker_ptr marker = (my_marker_ptr)cinfo->marker;
+  my_marker_ptr marker = (my_marker_ptr) cinfo->marker;

  emit_marker(cinfo, M_SOI);    /* first the SOI */

@@ -495,7 +496,7 @@ write_file_header(j_compress_ptr cinfo)
 */

 METHODDEF(void)
-write_frame_header(j_compress_ptr cinfo)
+write_frame_header (j_compress_ptr cinfo)
 {
  int ci, prec;
  boolean is_baseline;
@@ -555,9 +556,9 @@ write_frame_header(j_compress_ptr cinfo)
 */

 METHODDEF(void)
-write_scan_header(j_compress_ptr cinfo)
+write_scan_header (j_compress_ptr cinfo)
 {
-  my_marker_ptr marker = (my_marker_ptr)cinfo->marker;
+  my_marker_ptr marker = (my_marker_ptr) cinfo->marker;
  int i;
  jpeg_component_info *compptr;

@@ -599,7 +600,7 @@ write_scan_header(j_compress_ptr cinfo)
 */

 METHODDEF(void)
-write_file_trailer(j_compress_ptr cinfo)
+write_file_trailer (j_compress_ptr cinfo)
 {
  emit_marker(cinfo, M_EOI);
 }
@@ -613,7 +614,7 @@ write_file_trailer(j_compress_ptr cinfo)
 */

 METHODDEF(void)
-write_tables_only(j_compress_ptr cinfo)
+write_tables_only (j_compress_ptr cinfo)
 {
  int i;

@@ -621,10 +622,10 @@ write_tables_only(j_compress_ptr cinfo)

  for (i = 0; i < NUM_QUANT_TBLS; i++) {
    if (cinfo->quant_tbl_ptrs[i] != NULL)
-      (void)emit_dqt(cinfo, i);
+      (void) emit_dqt(cinfo, i);
  }

-  if (!cinfo->arith_code) {
+  if (! cinfo->arith_code) {
    for (i = 0; i < NUM_HUFF_TBLS; i++) {
      if (cinfo->dc_huff_tbl_ptrs[i] != NULL)
        emit_dht(cinfo, i, FALSE);
@@ -642,15 +643,15 @@ write_tables_only(j_compress_ptr cinfo)
 */

 GLOBAL(void)
-jinit_marker_writer(j_compress_ptr cinfo)
+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,
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                sizeof(my_marker_writer));
-  cinfo->marker = (struct jpeg_marker_writer *)marker;
+  cinfo->marker = (struct jpeg_marker_writer *) marker;
  /* Initialize method pointers */
  marker->pub.write_file_header = write_file_header;
  marker->pub.write_frame_header = write_frame_header;
@@ -5,7 +5,7 @@
 * Copyright (C) 1991-1997, Thomas G. Lane.
 * Modified 2003-2010 by Guido Vollbeding.
 * libjpeg-turbo Modifications:
- * Copyright (C) 2010, 2016, 2018, D. R. Commander.
+ * Copyright (C) 2010, 2016, D. R. Commander.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
 *
@@ -25,9 +25,9 @@
 /* Private state */

 typedef enum {
-  main_pass,                    /* input data, also do first output step */
-  huff_opt_pass,                /* Huffman code optimization pass */
-  output_pass                   /* data output pass */
+        main_pass,              /* input data, also do first output step */
+        huff_opt_pass,          /* Huffman code optimization pass */
+        output_pass             /* data output pass */
 } c_pass_type;

 typedef struct {
@@ -66,7 +66,7 @@ typedef my_comp_master *my_master_ptr;
 */

 GLOBAL(void)
-jpeg_calc_jpeg_dimensions(j_compress_ptr cinfo)
+jpeg_calc_jpeg_dimensions (j_compress_ptr cinfo)
 /* Do computations that are needed before master selection phase */
 {
  /* Hardwire it to "no scaling" */
@@ -79,7 +79,7 @@ jpeg_calc_jpeg_dimensions(j_compress_ptr cinfo)


 LOCAL(void)
-initial_setup(j_compress_ptr cinfo, boolean transcode_only)
+initial_setup (j_compress_ptr cinfo, boolean transcode_only)
 /* Do computations that are needed before master selection phase */
 {
  int ci;
@@ -95,19 +95,19 @@ initial_setup(j_compress_ptr cinfo, boolean transcode_only)
 #endif

  /* Sanity check on image dimensions */
-  if (cinfo->_jpeg_height <= 0 || cinfo->_jpeg_width <= 0 ||
-      cinfo->num_components <= 0 || cinfo->input_components <= 0)
+  if (cinfo->_jpeg_height <= 0 || cinfo->_jpeg_width <= 0
+      || cinfo->num_components <= 0 || cinfo->input_components <= 0)
    ERREXIT(cinfo, JERR_EMPTY_IMAGE);

  /* Make sure image isn't bigger than I can handle */
-  if ((long)cinfo->_jpeg_height > (long)JPEG_MAX_DIMENSION ||
-      (long)cinfo->_jpeg_width > (long)JPEG_MAX_DIMENSION)
-    ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int)JPEG_MAX_DIMENSION);
+  if ((long) cinfo->_jpeg_height > (long) JPEG_MAX_DIMENSION ||
+      (long) cinfo->_jpeg_width > (long) JPEG_MAX_DIMENSION)
+    ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) JPEG_MAX_DIMENSION);

  /* Width of an input scanline must be representable as JDIMENSION. */
-  samplesperrow = (long)cinfo->image_width * (long)cinfo->input_components;
-  jd_samplesperrow = (JDIMENSION)samplesperrow;
-  if ((long)jd_samplesperrow != samplesperrow)
+  samplesperrow = (long) cinfo->image_width * (long) cinfo->input_components;
+  jd_samplesperrow = (JDIMENSION) samplesperrow;
+  if ((long) jd_samplesperrow != samplesperrow)
    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);

  /* For now, precision must match compiled-in value... */
@@ -124,10 +124,8 @@ initial_setup(j_compress_ptr cinfo, boolean transcode_only)
  cinfo->max_v_samp_factor = 1;
  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
       ci++, compptr++) {
-    if (compptr->h_samp_factor <= 0 ||
-        compptr->h_samp_factor > MAX_SAMP_FACTOR ||
-        compptr->v_samp_factor <= 0 ||
-        compptr->v_samp_factor > MAX_SAMP_FACTOR)
+    if (compptr->h_samp_factor<=0 || compptr->h_samp_factor>MAX_SAMP_FACTOR ||
+        compptr->v_samp_factor<=0 || compptr->v_samp_factor>MAX_SAMP_FACTOR)
      ERREXIT(cinfo, JERR_BAD_SAMPLING);
    cinfo->max_h_samp_factor = MAX(cinfo->max_h_samp_factor,
                                   compptr->h_samp_factor);
@@ -148,18 +146,18 @@ initial_setup(j_compress_ptr cinfo, boolean transcode_only)
 #endif
    /* Size in DCT blocks */
    compptr->width_in_blocks = (JDIMENSION)
-      jdiv_round_up((long)cinfo->_jpeg_width * (long)compptr->h_samp_factor,
-                    (long)(cinfo->max_h_samp_factor * DCTSIZE));
+      jdiv_round_up((long) cinfo->_jpeg_width * (long) compptr->h_samp_factor,
+                    (long) (cinfo->max_h_samp_factor * DCTSIZE));
    compptr->height_in_blocks = (JDIMENSION)
-      jdiv_round_up((long)cinfo->_jpeg_height * (long)compptr->v_samp_factor,
-                    (long)(cinfo->max_v_samp_factor * DCTSIZE));
+      jdiv_round_up((long) cinfo->_jpeg_height * (long) compptr->v_samp_factor,
+                    (long) (cinfo->max_v_samp_factor * DCTSIZE));
    /* Size in samples */
    compptr->downsampled_width = (JDIMENSION)
-      jdiv_round_up((long)cinfo->_jpeg_width * (long)compptr->h_samp_factor,
-                    (long)cinfo->max_h_samp_factor);
+      jdiv_round_up((long) cinfo->_jpeg_width * (long) compptr->h_samp_factor,
+                    (long) cinfo->max_h_samp_factor);
    compptr->downsampled_height = (JDIMENSION)
-      jdiv_round_up((long)cinfo->_jpeg_height * (long)compptr->v_samp_factor,
-                    (long)cinfo->max_v_samp_factor);
+      jdiv_round_up((long) cinfo->_jpeg_height * (long) compptr->v_samp_factor,
+                    (long) cinfo->max_v_samp_factor);
    /* Mark component needed (this flag isn't actually used for compression) */
    compptr->component_needed = TRUE;
  }
@@ -168,15 +166,15 @@ initial_setup(j_compress_ptr cinfo, boolean transcode_only)
   * main controller will call coefficient controller).
   */
  cinfo->total_iMCU_rows = (JDIMENSION)
-    jdiv_round_up((long)cinfo->_jpeg_height,
-                  (long)(cinfo->max_v_samp_factor * DCTSIZE));
+    jdiv_round_up((long) cinfo->_jpeg_height,
+                  (long) (cinfo->max_v_samp_factor*DCTSIZE));
 }


 #ifdef C_MULTISCAN_FILES_SUPPORTED

 LOCAL(void)
-validate_script(j_compress_ptr cinfo)
+validate_script (j_compress_ptr cinfo)
 /* Verify that the scan script in cinfo->scan_info[] is valid; also
 * determine whether it uses progressive JPEG, and set cinfo->progressive_mode.
 */
@@ -198,10 +196,10 @@ validate_script(j_compress_ptr cinfo)
   * for progressive JPEG, no scan can have this.
   */
  scanptr = cinfo->scan_info;
-  if (scanptr->Ss != 0 || scanptr->Se != DCTSIZE2 - 1) {
+  if (scanptr->Ss != 0 || scanptr->Se != DCTSIZE2-1) {
 #ifdef C_PROGRESSIVE_SUPPORTED
    cinfo->progressive_mode = TRUE;
-    last_bitpos_ptr = &last_bitpos[0][0];
+    last_bitpos_ptr = & last_bitpos[0][0];
    for (ci = 0; ci < cinfo->num_components; ci++)
      for (coefi = 0; coefi < DCTSIZE2; coefi++)
        *last_bitpos_ptr++ = -1;
@@ -224,7 +222,7 @@ validate_script(j_compress_ptr cinfo)
      if (thisi < 0 || thisi >= cinfo->num_components)
        ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno);
      /* Components must appear in SOF order within each scan */
-      if (ci > 0 && thisi <= scanptr->component_index[ci - 1])
+      if (ci > 0 && thisi <= scanptr->component_index[ci-1])
        ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno);
    }
    /* Validate progression parameters */
@@ -234,17 +232,17 @@ validate_script(j_compress_ptr cinfo)
    Al = scanptr->Al;
    if (cinfo->progressive_mode) {
 #ifdef C_PROGRESSIVE_SUPPORTED
-      /* Rec. ITU-T T.81 | ISO/IEC 10918-1 simply gives the ranges 0..13 for Ah
-       * and Al, but that seems wrong: the upper bound ought to depend on data
-       * precision.  Perhaps they really meant 0..N+1 for N-bit precision.
+      /* The JPEG spec simply gives the ranges 0..13 for Ah and Al, but that
+       * seems wrong: the upper bound ought to depend on data precision.
+       * Perhaps they really meant 0..N+1 for N-bit precision.
       * Here we allow 0..10 for 8-bit data; Al larger than 10 results in
       * out-of-range reconstructed DC values during the first DC scan,
       * which might cause problems for some decoders.
       */
 #if BITS_IN_JSAMPLE == 8
-#define MAX_AH_AL  10
+#define MAX_AH_AL 10
 #else
-#define MAX_AH_AL  13
+#define MAX_AH_AL 13
 #endif
      if (Ss < 0 || Ss >= DCTSIZE2 || Se < Ss || Se >= DCTSIZE2 ||
          Ah < 0 || Ah > MAX_AH_AL || Al < 0 || Al > MAX_AH_AL)
@@ -257,7 +255,7 @@ validate_script(j_compress_ptr cinfo)
          ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
      }
      for (ci = 0; ci < ncomps; ci++) {
-        last_bitpos_ptr = &last_bitpos[scanptr->component_index[ci]][0];
+        last_bitpos_ptr = & last_bitpos[scanptr->component_index[ci]][0];
        if (Ss != 0 && last_bitpos_ptr[0] < 0) /* AC without prior DC scan */
          ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
        for (coefi = Ss; coefi <= Se; coefi++) {
@@ -267,7 +265,7 @@ validate_script(j_compress_ptr cinfo)
              ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
          } else {
            /* not first scan */
-            if (Ah != last_bitpos_ptr[coefi] || Al != Ah - 1)
+            if (Ah != last_bitpos_ptr[coefi] || Al != Ah-1)
              ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
          }
          last_bitpos_ptr[coefi] = Al;
@@ -276,7 +274,7 @@ validate_script(j_compress_ptr cinfo)
 #endif
    } else {
      /* For sequential JPEG, all progression parameters must be these: */
-      if (Ss != 0 || Se != DCTSIZE2 - 1 || Ah != 0 || Al != 0)
+      if (Ss != 0 || Se != DCTSIZE2-1 || Ah != 0 || Al != 0)
        ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
      /* Make sure components are not sent twice */
      for (ci = 0; ci < ncomps; ci++) {
@@ -303,7 +301,7 @@ validate_script(j_compress_ptr cinfo)
 #endif
  } else {
    for (ci = 0; ci < cinfo->num_components; ci++) {
-      if (!component_sent[ci])
+      if (! component_sent[ci])
        ERREXIT(cinfo, JERR_MISSING_DATA);
    }
  }
@@ -313,7 +311,7 @@ validate_script(j_compress_ptr cinfo)


 LOCAL(void)
-select_scan_parameters(j_compress_ptr cinfo)
+select_scan_parameters (j_compress_ptr cinfo)
 /* Set up the scan parameters for the current scan */
 {
  int ci;
@@ -321,7 +319,7 @@ select_scan_parameters(j_compress_ptr cinfo)
 #ifdef C_MULTISCAN_FILES_SUPPORTED
  if (cinfo->scan_info != NULL) {
    /* Prepare for current scan --- the script is already validated */
-    my_master_ptr master = (my_master_ptr)cinfo->master;
+    my_master_ptr master = (my_master_ptr) cinfo->master;
    const jpeg_scan_info *scanptr = cinfo->scan_info + master->scan_number;

    cinfo->comps_in_scan = scanptr->comps_in_scan;
@@ -333,7 +331,8 @@ select_scan_parameters(j_compress_ptr cinfo)
    cinfo->Se = scanptr->Se;
    cinfo->Ah = scanptr->Ah;
    cinfo->Al = scanptr->Al;
-  } else
+  }
+  else
 #endif
  {
    /* Prepare for single sequential-JPEG scan containing all components */
@@ -345,7 +344,7 @@ select_scan_parameters(j_compress_ptr cinfo)
      cinfo->cur_comp_info[ci] = &cinfo->comp_info[ci];
    }
    cinfo->Ss = 0;
-    cinfo->Se = DCTSIZE2 - 1;
+    cinfo->Se = DCTSIZE2-1;
    cinfo->Ah = 0;
    cinfo->Al = 0;
  }
@@ -353,7 +352,7 @@ select_scan_parameters(j_compress_ptr cinfo)


 LOCAL(void)
-per_scan_setup(j_compress_ptr cinfo)
+per_scan_setup (j_compress_ptr cinfo)
 /* Do computations that are needed before processing a JPEG scan */
 /* cinfo->comps_in_scan and cinfo->cur_comp_info[] are already set */
 {
@@ -378,7 +377,7 @@ per_scan_setup(j_compress_ptr cinfo)
    /* For noninterleaved scans, it is convenient to define last_row_height
     * as the number of block rows present in the last iMCU row.
     */
-    tmp = (int)(compptr->height_in_blocks % compptr->v_samp_factor);
+    tmp = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
    if (tmp == 0) tmp = compptr->v_samp_factor;
    compptr->last_row_height = tmp;

@@ -395,11 +394,11 @@ per_scan_setup(j_compress_ptr cinfo)

    /* Overall image size in MCUs */
    cinfo->MCUs_per_row = (JDIMENSION)
-      jdiv_round_up((long)cinfo->_jpeg_width,
-                    (long)(cinfo->max_h_samp_factor * DCTSIZE));
+      jdiv_round_up((long) cinfo->_jpeg_width,
+                    (long) (cinfo->max_h_samp_factor*DCTSIZE));
    cinfo->MCU_rows_in_scan = (JDIMENSION)
-      jdiv_round_up((long)cinfo->_jpeg_height,
-                    (long)(cinfo->max_v_samp_factor * DCTSIZE));
+      jdiv_round_up((long) cinfo->_jpeg_height,
+                    (long) (cinfo->max_v_samp_factor*DCTSIZE));

    cinfo->blocks_in_MCU = 0;

@@ -411,10 +410,10 @@ per_scan_setup(j_compress_ptr cinfo)
      compptr->MCU_blocks = compptr->MCU_width * compptr->MCU_height;
      compptr->MCU_sample_width = compptr->MCU_width * DCTSIZE;
      /* Figure number of non-dummy blocks in last MCU column & row */
-      tmp = (int)(compptr->width_in_blocks % compptr->MCU_width);
+      tmp = (int) (compptr->width_in_blocks % compptr->MCU_width);
      if (tmp == 0) tmp = compptr->MCU_width;
      compptr->last_col_width = tmp;
-      tmp = (int)(compptr->height_in_blocks % compptr->MCU_height);
+      tmp = (int) (compptr->height_in_blocks % compptr->MCU_height);
      if (tmp == 0) tmp = compptr->MCU_height;
      compptr->last_row_height = tmp;
      /* Prepare array describing MCU composition */
@@ -431,8 +430,8 @@ per_scan_setup(j_compress_ptr cinfo)
  /* Convert restart specified in rows to actual MCU count. */
  /* Note that count must fit in 16 bits, so we provide limiting. */
  if (cinfo->restart_in_rows > 0) {
-    long nominal = (long)cinfo->restart_in_rows * (long)cinfo->MCUs_per_row;
-    cinfo->restart_interval = (unsigned int)MIN(nominal, 65535L);
+    long nominal = (long) cinfo->restart_in_rows * (long) cinfo->MCUs_per_row;
+    cinfo->restart_interval = (unsigned int) MIN(nominal, 65535L);
  }
 }

@@ -446,9 +445,9 @@ per_scan_setup(j_compress_ptr cinfo)
 */

 METHODDEF(void)
-prepare_for_pass(j_compress_ptr cinfo)
+prepare_for_pass (j_compress_ptr cinfo)
 {
-  my_master_ptr master = (my_master_ptr)cinfo->master;
+  my_master_ptr master = (my_master_ptr) cinfo->master;

  switch (master->pass_type) {
  case main_pass:
@@ -457,7 +456,7 @@ prepare_for_pass(j_compress_ptr cinfo)
     */
    select_scan_parameters(cinfo);
    per_scan_setup(cinfo);
-    if (!cinfo->raw_data_in) {
+    if (! cinfo->raw_data_in) {
      (*cinfo->cconvert->start_pass) (cinfo);
      (*cinfo->downsample->start_pass) (cinfo);
      (*cinfo->prep->start_pass) (cinfo, JBUF_PASS_THRU);
@@ -492,12 +491,12 @@ prepare_for_pass(j_compress_ptr cinfo)
     */
    master->pass_type = output_pass;
    master->pass_number++;
+    /*FALLTHROUGH*/
 #endif
-    FALLTHROUGH                 /*FALLTHROUGH*/
  case output_pass:
    /* Do a data-output pass. */
    /* We need not repeat per-scan setup if prior optimization pass did it. */
-    if (!cinfo->optimize_coding) {
+    if (! cinfo->optimize_coding) {
      select_scan_parameters(cinfo);
      per_scan_setup(cinfo);
    }
@@ -513,7 +512,7 @@ prepare_for_pass(j_compress_ptr cinfo)
    ERREXIT(cinfo, JERR_NOT_COMPILED);
  }

-  master->pub.is_last_pass = (master->pass_number == master->total_passes - 1);
+  master->pub.is_last_pass = (master->pass_number == master->total_passes-1);

  /* Set up progress monitor's pass info if present */
  if (cinfo->progress != NULL) {
@@ -534,7 +533,7 @@ prepare_for_pass(j_compress_ptr cinfo)
 */

 METHODDEF(void)
-pass_startup(j_compress_ptr cinfo)
+pass_startup (j_compress_ptr cinfo)
 {
  cinfo->master->call_pass_startup = FALSE; /* reset flag so call only once */

@@ -548,9 +547,9 @@ pass_startup(j_compress_ptr cinfo)
 */

 METHODDEF(void)
-finish_pass_master(j_compress_ptr cinfo)
+finish_pass_master (j_compress_ptr cinfo)
 {
-  my_master_ptr master = (my_master_ptr)cinfo->master;
+  my_master_ptr master = (my_master_ptr) cinfo->master;

  /* The entropy coder always needs an end-of-pass call,
   * either to analyze statistics or to flush its output buffer.
@@ -564,7 +563,7 @@ finish_pass_master(j_compress_ptr cinfo)
     * or output of scan 1 (if no optimization).
     */
    master->pass_type = output_pass;
-    if (!cinfo->optimize_coding)
+    if (! cinfo->optimize_coding)
      master->scan_number++;
    break;
  case huff_opt_pass:
@@ -588,14 +587,14 @@ finish_pass_master(j_compress_ptr cinfo)
 */

 GLOBAL(void)
-jinit_c_master_control(j_compress_ptr cinfo, boolean transcode_only)
+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));
-  cinfo->master = (struct jpeg_comp_master *)master;
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+                                  sizeof(my_comp_master));
+  cinfo->master = (struct jpeg_comp_master *) master;
  master->pub.prepare_for_pass = prepare_for_pass;
  master->pub.pass_startup = pass_startup;
  master->pub.finish_pass = finish_pass_master;
@@ -29,7 +29,7 @@
 */

 GLOBAL(void)
-jpeg_abort(j_common_ptr cinfo)
+jpeg_abort (j_common_ptr cinfo)
 {
  int pool;

@@ -40,7 +40,7 @@ jpeg_abort(j_common_ptr cinfo)
  /* Releasing pools in reverse order might help avoid fragmentation
   * with some (brain-damaged) malloc libraries.
   */
-  for (pool = JPOOL_NUMPOOLS - 1; pool > JPOOL_PERMANENT; pool--) {
+  for (pool = JPOOL_NUMPOOLS-1; pool > JPOOL_PERMANENT; pool--) {
    (*cinfo->mem->free_pool) (cinfo, pool);
  }

@@ -50,7 +50,7 @@ jpeg_abort(j_common_ptr cinfo)
    /* Try to keep application from accessing now-deleted marker list.
     * A bit kludgy to do it here, but this is the most central place.
     */
-    ((j_decompress_ptr)cinfo)->marker_list = NULL;
+    ((j_decompress_ptr) cinfo)->marker_list = NULL;
  } else {
    cinfo->global_state = CSTATE_START;
  }
@@ -69,7 +69,7 @@ jpeg_abort(j_common_ptr cinfo)
 */

 GLOBAL(void)
-jpeg_destroy(j_common_ptr cinfo)
+jpeg_destroy (j_common_ptr cinfo)
 {
  /* We need only tell the memory manager to release everything. */
  /* NB: mem pointer is NULL if memory mgr failed to initialize. */
@@ -86,7 +86,7 @@ jpeg_destroy(j_common_ptr cinfo)
 */

 GLOBAL(JQUANT_TBL *)
-jpeg_alloc_quant_table(j_common_ptr cinfo)
+jpeg_alloc_quant_table (j_common_ptr cinfo)
 {
  JQUANT_TBL *tbl;

@@ -98,7 +98,7 @@ jpeg_alloc_quant_table(j_common_ptr cinfo)


 GLOBAL(JHUFF_TBL *)
-jpeg_alloc_huff_table(j_common_ptr cinfo)
+jpeg_alloc_huff_table (j_common_ptr cinfo)
 {
  JHUFF_TBL *tbl;

@@ -5,7 +5,7 @@
 * Copyright (C) 1991-1998, Thomas G. Lane.
 * Modified 2003-2008 by Guido Vollbeding.
 * libjpeg-turbo Modifications:
- * Copyright (C) 2009-2011, 2018, D. R. Commander.
+ * Copyright (C) 2009-2011, D. R. Commander.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
 *
@@ -25,9 +25,9 @@
 */

 GLOBAL(void)
-jpeg_add_quant_table(j_compress_ptr cinfo, int which_tbl,
-                     const unsigned int *basic_table, int scale_factor,
-                     boolean force_baseline)
+jpeg_add_quant_table (j_compress_ptr cinfo, int which_tbl,
+                      const unsigned int *basic_table,
+                      int scale_factor, boolean force_baseline)
 /* Define a quantization table equal to the basic_table times
 * a scale factor (given as a percentage).
 * If force_baseline is TRUE, the computed quantization table entries
@@ -45,19 +45,19 @@ jpeg_add_quant_table(j_compress_ptr cinfo, int which_tbl,
  if (which_tbl < 0 || which_tbl >= NUM_QUANT_TBLS)
    ERREXIT1(cinfo, JERR_DQT_INDEX, which_tbl);

-  qtblptr = &cinfo->quant_tbl_ptrs[which_tbl];
+  qtblptr = & cinfo->quant_tbl_ptrs[which_tbl];

  if (*qtblptr == NULL)
-    *qtblptr = jpeg_alloc_quant_table((j_common_ptr)cinfo);
+    *qtblptr = jpeg_alloc_quant_table((j_common_ptr) cinfo);

  for (i = 0; i < DCTSIZE2; i++) {
-    temp = ((long)basic_table[i] * scale_factor + 50L) / 100L;
+    temp = ((long) basic_table[i] * scale_factor + 50L) / 100L;
    /* limit the values to the valid range */
    if (temp <= 0L) temp = 1L;
    if (temp > 32767L) temp = 32767L; /* max quantizer needed for 12 bits */
    if (force_baseline && temp > 255L)
      temp = 255L;              /* limit to baseline range if requested */
-    (*qtblptr)->quantval[i] = (UINT16)temp;
+    (*qtblptr)->quantval[i] = (UINT16) temp;
  }

  /* Initialize sent_table FALSE so table will be written to JPEG file. */
@@ -65,8 +65,7 @@ jpeg_add_quant_table(j_compress_ptr cinfo, int which_tbl,
 }


-/* These are the sample quantization tables given in Annex K (Clause K.1) of
- * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994.
+/* These are the sample quantization tables given in JPEG spec section K.1.
 * The spec says that the values given produce "good" quality, and
 * when divided by 2, "very good" quality.
 */
@@ -94,7 +93,7 @@ static const unsigned int std_chrominance_quant_tbl[DCTSIZE2] = {

 #if JPEG_LIB_VERSION >= 70
 GLOBAL(void)
-jpeg_default_qtables(j_compress_ptr cinfo, boolean force_baseline)
+jpeg_default_qtables (j_compress_ptr cinfo, boolean force_baseline)
 /* Set or change the 'quality' (quantization) setting, using default tables
 * and straight percentage-scaling quality scales.
 * This entry point allows different scalings for luminance and chrominance.
@@ -110,8 +109,8 @@ jpeg_default_qtables(j_compress_ptr cinfo, boolean force_baseline)


 GLOBAL(void)
-jpeg_set_linear_quality(j_compress_ptr cinfo, int scale_factor,
-                        boolean force_baseline)
+jpeg_set_linear_quality (j_compress_ptr cinfo, int scale_factor,
+                         boolean force_baseline)
 /* Set or change the 'quality' (quantization) setting, using default tables
 * and a straight percentage-scaling quality scale.  In most cases it's better
 * to use jpeg_set_quality (below); this entry point is provided for
@@ -127,7 +126,7 @@ jpeg_set_linear_quality(j_compress_ptr cinfo, int scale_factor,


 GLOBAL(int)
-jpeg_quality_scaling(int quality)
+jpeg_quality_scaling (int quality)
 /* Convert a user-specified quality rating to a percentage scaling factor
 * for an underlying quantization table, using our recommended scaling curve.
 * The input 'quality' factor should be 0 (terrible) to 100 (very good).
@@ -146,14 +145,14 @@ jpeg_quality_scaling(int quality)
  if (quality < 50)
    quality = 5000 / quality;
  else
-    quality = 200 - quality * 2;
+    quality = 200 - quality*2;

  return quality;
 }


 GLOBAL(void)
-jpeg_set_quality(j_compress_ptr cinfo, int quality, boolean force_baseline)
+jpeg_set_quality (j_compress_ptr cinfo, int quality, boolean force_baseline)
 /* Set or change the 'quality' (quantization) setting, using default tables.
 * This is the standard quality-adjusting entry point for typical user
 * interfaces; only those who want detailed control over quantization tables
@@ -179,7 +178,7 @@ jpeg_set_quality(j_compress_ptr cinfo, int quality, boolean force_baseline)
 */

 GLOBAL(void)
-jpeg_set_defaults(j_compress_ptr cinfo)
+jpeg_set_defaults (j_compress_ptr cinfo)
 {
  int i;

@@ -193,7 +192,7 @@ jpeg_set_defaults(j_compress_ptr cinfo)
   */
  if (cinfo->comp_info == NULL)
    cinfo->comp_info = (jpeg_component_info *)
-      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
                                  MAX_COMPONENTS * sizeof(jpeg_component_info));

  /* Initialize everything not dependent on the color space */
@@ -206,7 +205,7 @@ jpeg_set_defaults(j_compress_ptr cinfo)
  /* Set up two quantization tables using default quality of 75 */
  jpeg_set_quality(cinfo, 75, TRUE);
  /* Set up two Huffman tables */
-  std_huff_tables((j_common_ptr)cinfo);
+  std_huff_tables((j_common_ptr) cinfo);

  /* Initialize default arithmetic coding conditioning */
  for (i = 0; i < NUM_ARITH_TBLS; i++) {
@@ -279,7 +278,7 @@ jpeg_set_defaults(j_compress_ptr cinfo)
 */

 GLOBAL(void)
-jpeg_default_colorspace(j_compress_ptr cinfo)
+jpeg_default_colorspace (j_compress_ptr cinfo)
 {
  switch (cinfo->in_color_space) {
  case JCS_GRAYSCALE:
@@ -321,12 +320,12 @@ jpeg_default_colorspace(j_compress_ptr cinfo)
 */

 GLOBAL(void)
-jpeg_set_colorspace(j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
+jpeg_set_colorspace (j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
 {
  jpeg_component_info *compptr;
  int ci;

-#define SET_COMP(index, id, hsamp, vsamp, quant, dctbl, actbl) \
+#define SET_COMP(index,id,hsamp,vsamp,quant,dctbl,actbl)  \
  (compptr = &cinfo->comp_info[index], \
   compptr->component_id = (id), \
   compptr->h_samp_factor = (hsamp), \
@@ -353,39 +352,39 @@ jpeg_set_colorspace(j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
    cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
    cinfo->num_components = 1;
    /* JFIF specifies component ID 1 */
-    SET_COMP(0, 1, 1, 1, 0, 0, 0);
+    SET_COMP(0, 1, 1,1, 0, 0,0);
    break;
  case JCS_RGB:
    cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag RGB */
    cinfo->num_components = 3;
-    SET_COMP(0, 0x52 /* 'R' */, 1, 1, 0, 0, 0);
-    SET_COMP(1, 0x47 /* 'G' */, 1, 1, 0, 0, 0);
-    SET_COMP(2, 0x42 /* 'B' */, 1, 1, 0, 0, 0);
+    SET_COMP(0, 0x52 /* 'R' */, 1,1, 0, 0,0);
+    SET_COMP(1, 0x47 /* 'G' */, 1,1, 0, 0,0);
+    SET_COMP(2, 0x42 /* 'B' */, 1,1, 0, 0,0);
    break;
  case JCS_YCbCr:
    cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
    cinfo->num_components = 3;
    /* JFIF specifies component IDs 1,2,3 */
    /* We default to 2x2 subsamples of chrominance */
-    SET_COMP(0, 1, 2, 2, 0, 0, 0);
-    SET_COMP(1, 2, 1, 1, 1, 1, 1);
-    SET_COMP(2, 3, 1, 1, 1, 1, 1);
+    SET_COMP(0, 1, 2,2, 0, 0,0);
+    SET_COMP(1, 2, 1,1, 1, 1,1);
+    SET_COMP(2, 3, 1,1, 1, 1,1);
    break;
  case JCS_CMYK:
    cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag CMYK */
    cinfo->num_components = 4;
-    SET_COMP(0, 0x43 /* 'C' */, 1, 1, 0, 0, 0);
-    SET_COMP(1, 0x4D /* 'M' */, 1, 1, 0, 0, 0);
-    SET_COMP(2, 0x59 /* 'Y' */, 1, 1, 0, 0, 0);
-    SET_COMP(3, 0x4B /* 'K' */, 1, 1, 0, 0, 0);
+    SET_COMP(0, 0x43 /* 'C' */, 1,1, 0, 0,0);
+    SET_COMP(1, 0x4D /* 'M' */, 1,1, 0, 0,0);
+    SET_COMP(2, 0x59 /* 'Y' */, 1,1, 0, 0,0);
+    SET_COMP(3, 0x4B /* 'K' */, 1,1, 0, 0,0);
    break;
  case JCS_YCCK:
    cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag YCCK */
    cinfo->num_components = 4;
-    SET_COMP(0, 1, 2, 2, 0, 0, 0);
-    SET_COMP(1, 2, 1, 1, 1, 1, 1);
-    SET_COMP(2, 3, 1, 1, 1, 1, 1);
-    SET_COMP(3, 4, 2, 2, 0, 0, 0);
+    SET_COMP(0, 1, 2,2, 0, 0,0);
+    SET_COMP(1, 2, 1,1, 1, 1,1);
+    SET_COMP(2, 3, 1,1, 1, 1,1);
+    SET_COMP(3, 4, 2,2, 0, 0,0);
    break;
  case JCS_UNKNOWN:
    cinfo->num_components = cinfo->input_components;
@@ -393,7 +392,7 @@ jpeg_set_colorspace(j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
      ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
               MAX_COMPONENTS);
    for (ci = 0; ci < cinfo->num_components; ci++) {
-      SET_COMP(ci, ci, 1, 1, 0, 0, 0);
+      SET_COMP(ci, ci, 1,1, 0, 0,0);
    }
    break;
  default:
@@ -405,7 +404,8 @@ jpeg_set_colorspace(j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
 #ifdef C_PROGRESSIVE_SUPPORTED

 LOCAL(jpeg_scan_info *)
-fill_a_scan(jpeg_scan_info *scanptr, int ci, int Ss, int Se, int Ah, int Al)
+fill_a_scan (jpeg_scan_info *scanptr, int ci,
+             int Ss, int Se, int Ah, int Al)
 /* Support routine: generate one scan for specified component */
 {
  scanptr->comps_in_scan = 1;
@@ -419,7 +419,8 @@ fill_a_scan(jpeg_scan_info *scanptr, int ci, int Ss, int Se, int Ah, int Al)
 }

 LOCAL(jpeg_scan_info *)
-fill_scans(jpeg_scan_info *scanptr, int ncomps, int Ss, int Se, int Ah, int Al)
+fill_scans (jpeg_scan_info *scanptr, int ncomps,
+            int Ss, int Se, int Ah, int Al)
 /* Support routine: generate one scan for each component */
 {
  int ci;
@@ -437,7 +438,7 @@ fill_scans(jpeg_scan_info *scanptr, int ncomps, int Ss, int Se, int Ah, int Al)
 }

 LOCAL(jpeg_scan_info *)
-fill_dc_scans(jpeg_scan_info *scanptr, int ncomps, int Ah, int Al)
+fill_dc_scans (jpeg_scan_info *scanptr, int ncomps, int Ah, int Al)
 /* Support routine: generate interleaved DC scan if possible, else N scans */
 {
  int ci;
@@ -465,7 +466,7 @@ fill_dc_scans(jpeg_scan_info *scanptr, int ncomps, int Ah, int Al)
 */

 GLOBAL(void)
-jpeg_simple_progression(j_compress_ptr cinfo)
+jpeg_simple_progression (j_compress_ptr cinfo)
 {
  int ncomps = cinfo->num_components;
  int nscans;
@@ -497,7 +498,7 @@ jpeg_simple_progression(j_compress_ptr cinfo)
  if (cinfo->script_space == NULL || cinfo->script_space_size < nscans) {
    cinfo->script_space_size = MAX(nscans, 10);
    cinfo->script_space = (jpeg_scan_info *)
-      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
                        cinfo->script_space_size * sizeof(jpeg_scan_info));
  }
  scanptr = cinfo->script_space;
@@ -4,10 +4,7 @@
 * This file was part of the Independent JPEG Group's software:
 * Copyright (C) 1995-1997, Thomas G. Lane.
 * libjpeg-turbo Modifications:
- * Copyright (C) 2011, 2015, 2018, 2021, D. R. Commander.
- * Copyright (C) 2016, 2018, Matthieu Darbois.
- * Copyright (C) 2020, Arm Limited.
- * Copyright (C) 2021, Alex Richardson.
+ * Copyright (C) 2015, D. R. Commander.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
 *
@@ -21,74 +18,15 @@
 #define JPEG_INTERNALS
 #include "jinclude.h"
 #include "jpeglib.h"
-#include "jsimd.h"
-#include "jconfigint.h"
-#include <limits.h>
-
-#ifdef HAVE_INTRIN_H
-#include <intrin.h>
-#ifdef _MSC_VER
-#ifdef HAVE_BITSCANFORWARD64
-#pragma intrinsic(_BitScanForward64)
-#endif
-#ifdef HAVE_BITSCANFORWARD
-#pragma intrinsic(_BitScanForward)
-#endif
-#endif
-#endif
+#include "jchuff.h"             /* Declarations shared with jchuff.c */

 #ifdef C_PROGRESSIVE_SUPPORTED

-/*
- * NOTE: If USE_CLZ_INTRINSIC is defined, then clz/bsr instructions will be
- * used for bit counting rather than the lookup table.  This will reduce the
- * memory footprint by 64k, which is important for some mobile applications
- * that create many isolated instances of libjpeg-turbo (web browsers, for
- * instance.)  This may improve performance on some mobile platforms as well.
- * This feature is enabled by default only on Arm processors, because some x86
- * chips have a slow implementation of bsr, and the use of clz/bsr cannot be
- * shown to have a significant performance impact even on the x86 chips that
- * have a fast implementation of it.  When building for Armv6, you can
- * explicitly disable the use of clz/bsr by adding -mthumb to the compiler
- * flags (this defines __thumb__).
- */
-
-/* NOTE: Both GCC and Clang define __GNUC__ */
-#if (defined(__GNUC__) && (defined(__arm__) || defined(__aarch64__))) || \
-    defined(_M_ARM) || defined(_M_ARM64)
-#if !defined(__thumb__) || defined(__thumb2__)
-#define USE_CLZ_INTRINSIC
-#endif
-#endif
-
-#ifdef USE_CLZ_INTRINSIC
-#if defined(_MSC_VER) && !defined(__clang__)
-#define JPEG_NBITS_NONZERO(x)  (32 - _CountLeadingZeros(x))
-#else
-#define JPEG_NBITS_NONZERO(x)  (32 - __builtin_clz(x))
-#endif
-#define JPEG_NBITS(x)          (x ? JPEG_NBITS_NONZERO(x) : 0)
-#else
-#include "jpeg_nbits_table.h"
-#define JPEG_NBITS(x)          (jpeg_nbits_table[x])
-#define JPEG_NBITS_NONZERO(x)  JPEG_NBITS(x)
-#endif
-
-
 /* Expanded entropy encoder object for progressive Huffman encoding. */

 typedef struct {
  struct jpeg_entropy_encoder pub; /* public fields */

-  /* Pointer to routine to prepare data for encode_mcu_AC_first() */
-  void (*AC_first_prepare) (const JCOEF *block,
-                            const int *jpeg_natural_order_start, int Sl,
-                            int Al, JCOEF *values, size_t *zerobits);
-  /* Pointer to routine to prepare data for encode_mcu_AC_refine() */
-  int (*AC_refine_prepare) (const JCOEF *block,
-                            const int *jpeg_natural_order_start, int Sl,
-                            int Al, JCOEF *absvalues, size_t *bits);
-
  /* Mode flag: TRUE for optimization, FALSE for actual data output */
  boolean gather_statistics;

@@ -141,62 +79,26 @@ typedef phuff_entropy_encoder *phuff_entropy_ptr;

 #ifdef RIGHT_SHIFT_IS_UNSIGNED
 #define ISHIFT_TEMPS    int ishift_temp;
-#define IRIGHT_SHIFT(x, shft) \
-  ((ishift_temp = (x)) < 0 ? \
-   (ishift_temp >> (shft)) | ((~0) << (16 - (shft))) : \
-   (ishift_temp >> (shft)))
+#define IRIGHT_SHIFT(x,shft)  \
+        ((ishift_temp = (x)) < 0 ? \
+         (ishift_temp >> (shft)) | ((~0) << (16-(shft))) : \
+         (ishift_temp >> (shft)))
 #else
 #define ISHIFT_TEMPS
-#define IRIGHT_SHIFT(x, shft)   ((x) >> (shft))
+#define IRIGHT_SHIFT(x,shft)    ((x) >> (shft))
 #endif

-#define PAD(v, p)  ((v + (p) - 1) & (~((p) - 1)))
-
 /* Forward declarations */
-METHODDEF(boolean) encode_mcu_DC_first(j_compress_ptr cinfo,
-                                       JBLOCKROW *MCU_data);
-METHODDEF(void) encode_mcu_AC_first_prepare
-  (const JCOEF *block, const int *jpeg_natural_order_start, int Sl, int Al,
-   JCOEF *values, size_t *zerobits);
-METHODDEF(boolean) encode_mcu_AC_first(j_compress_ptr cinfo,
-                                       JBLOCKROW *MCU_data);
-METHODDEF(boolean) encode_mcu_DC_refine(j_compress_ptr cinfo,
+METHODDEF(boolean) encode_mcu_DC_first (j_compress_ptr cinfo,
                                        JBLOCKROW *MCU_data);
-METHODDEF(int) encode_mcu_AC_refine_prepare
-  (const JCOEF *block, const int *jpeg_natural_order_start, int Sl, int Al,
-   JCOEF *absvalues, size_t *bits);
-METHODDEF(boolean) encode_mcu_AC_refine(j_compress_ptr cinfo,
+METHODDEF(boolean) encode_mcu_AC_first (j_compress_ptr cinfo,
                                        JBLOCKROW *MCU_data);
-METHODDEF(void) finish_pass_phuff(j_compress_ptr cinfo);
-METHODDEF(void) finish_pass_gather_phuff(j_compress_ptr cinfo);
-
-
-/* Count bit loop zeroes */
-INLINE
-METHODDEF(int)
-count_zeroes(size_t *x)
-{
-#if defined(HAVE_BUILTIN_CTZL)
-  int result;
-  result = __builtin_ctzl(*x);
-  *x >>= result;
-#elif defined(HAVE_BITSCANFORWARD64)
-  unsigned long result;
-  _BitScanForward64(&result, *x);
-  *x >>= result;
-#elif defined(HAVE_BITSCANFORWARD)
-  unsigned long result;
-  _BitScanForward(&result, *x);
-  *x >>= result;
-#else
-  int result = 0;
-  while ((*x & 1) == 0) {
-    ++result;
-    *x >>= 1;
-  }
-#endif
-  return (int)result;
-}
+METHODDEF(boolean) encode_mcu_DC_refine (j_compress_ptr cinfo,
+                                         JBLOCKROW *MCU_data);
+METHODDEF(boolean) encode_mcu_AC_refine (j_compress_ptr cinfo,
+                                         JBLOCKROW *MCU_data);
+METHODDEF(void) finish_pass_phuff (j_compress_ptr cinfo);
+METHODDEF(void) finish_pass_gather_phuff (j_compress_ptr cinfo);


 /*
@@ -204,9 +106,9 @@ count_zeroes(size_t *x)
 */

 METHODDEF(void)
-start_pass_phuff(j_compress_ptr cinfo, boolean gather_statistics)
+start_pass_phuff (j_compress_ptr cinfo, boolean gather_statistics)
 {
-  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
  boolean is_DC_band;
  int ci, tbl;
  jpeg_component_info *compptr;
@@ -224,23 +126,15 @@ start_pass_phuff(j_compress_ptr cinfo, boolean gather_statistics)
      entropy->pub.encode_mcu = encode_mcu_DC_first;
    else
      entropy->pub.encode_mcu = encode_mcu_AC_first;
-    if (jsimd_can_encode_mcu_AC_first_prepare())
-      entropy->AC_first_prepare = jsimd_encode_mcu_AC_first_prepare;
-    else
-      entropy->AC_first_prepare = encode_mcu_AC_first_prepare;
  } else {
    if (is_DC_band)
      entropy->pub.encode_mcu = encode_mcu_DC_refine;
    else {
      entropy->pub.encode_mcu = encode_mcu_AC_refine;
-      if (jsimd_can_encode_mcu_AC_refine_prepare())
-        entropy->AC_refine_prepare = jsimd_encode_mcu_AC_refine_prepare;
-      else
-        entropy->AC_refine_prepare = encode_mcu_AC_refine_prepare;
      /* 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,
+          (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                      MAX_CORR_BITS * sizeof(char));
    }
  }
@@ -273,14 +167,14 @@ start_pass_phuff(j_compress_ptr cinfo, boolean gather_statistics)
      /* Note that jpeg_gen_optimal_table expects 257 entries in each table! */
      if (entropy->count_ptrs[tbl] == NULL)
        entropy->count_ptrs[tbl] = (long *)
-          (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+          (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                      257 * sizeof(long));
      MEMZERO(entropy->count_ptrs[tbl], 257 * sizeof(long));
    } else {
      /* Compute derived values for Huffman table */
      /* We may do this more than once for a table, but it's not expensive */
      jpeg_make_c_derived_tbl(cinfo, is_DC_band, tbl,
-                              &entropy->derived_tbls[tbl]);
+                              & entropy->derived_tbls[tbl]);
    }
  }

@@ -304,20 +198,19 @@ start_pass_phuff(j_compress_ptr cinfo, boolean gather_statistics)
 */

 /* Emit a byte */
-#define emit_byte(entropy, val) { \
-  *(entropy)->next_output_byte++ = (JOCTET)(val); \
-  if (--(entropy)->free_in_buffer == 0) \
-    dump_buffer(entropy); \
-}
+#define emit_byte(entropy,val)  \
+        { *(entropy)->next_output_byte++ = (JOCTET) (val);  \
+          if (--(entropy)->free_in_buffer == 0)  \
+            dump_buffer(entropy); }


 LOCAL(void)
-dump_buffer(phuff_entropy_ptr entropy)
+dump_buffer (phuff_entropy_ptr entropy)
 /* Empty the output buffer; we do not support suspension in this module. */
 {
  struct jpeg_destination_mgr *dest = entropy->cinfo->dest;

-  if (!(*dest->empty_output_buffer) (entropy->cinfo))
+  if (! (*dest->empty_output_buffer) (entropy->cinfo))
    ERREXIT(entropy->cinfo, JERR_CANT_SUSPEND);
  /* After a successful buffer dump, must reset buffer pointers */
  entropy->next_output_byte = dest->next_output_byte;
@@ -334,11 +227,11 @@ dump_buffer(phuff_entropy_ptr entropy)
 */

 LOCAL(void)
-emit_bits(phuff_entropy_ptr entropy, unsigned int code, int size)
+emit_bits (phuff_entropy_ptr entropy, unsigned int code, int size)
 /* Emit some bits, unless we are in gather mode */
 {
  /* This routine is heavily used, so it's worth coding tightly. */
-  register size_t put_buffer = (size_t)code;
+  register size_t put_buffer = (size_t) code;
  register int put_bits = entropy->put_bits;

  /* if size is 0, caller used an invalid Huffman table entry */
@@ -348,7 +241,7 @@ emit_bits(phuff_entropy_ptr entropy, unsigned int code, int size)
  if (entropy->gather_statistics)
    return;                     /* do nothing if we're only getting stats */

-  put_buffer &= (((size_t)1) << size) - 1; /* mask off any extra bits in code */
+  put_buffer &= (((size_t) 1)<<size) - 1; /* mask off any extra bits in code */

  put_bits += size;             /* new number of bits in buffer */

@@ -357,7 +250,7 @@ emit_bits(phuff_entropy_ptr entropy, unsigned int code, int size)
  put_buffer |= entropy->put_buffer; /* and merge with old buffer contents */

  while (put_bits >= 8) {
-    int c = (int)((put_buffer >> 16) & 0xFF);
+    int c = (int) ((put_buffer >> 16) & 0xFF);

    emit_byte(entropy, c);
    if (c == 0xFF) {            /* need to stuff a zero byte? */
@@ -373,7 +266,7 @@ emit_bits(phuff_entropy_ptr entropy, unsigned int code, int size)


 LOCAL(void)
-flush_bits(phuff_entropy_ptr entropy)
+flush_bits (phuff_entropy_ptr entropy)
 {
  emit_bits(entropy, 0x7F, 7); /* fill any partial byte with ones */
  entropy->put_buffer = 0;     /* and reset bit-buffer to empty */
@@ -386,7 +279,7 @@ flush_bits(phuff_entropy_ptr entropy)
 */

 LOCAL(void)
-emit_symbol(phuff_entropy_ptr entropy, int tbl_no, int symbol)
+emit_symbol (phuff_entropy_ptr entropy, int tbl_no, int symbol)
 {
  if (entropy->gather_statistics)
    entropy->count_ptrs[tbl_no][symbol]++;
@@ -402,14 +295,14 @@ emit_symbol(phuff_entropy_ptr entropy, int tbl_no, int symbol)
 */

 LOCAL(void)
-emit_buffered_bits(phuff_entropy_ptr entropy, char *bufstart,
-                   unsigned int nbits)
+emit_buffered_bits (phuff_entropy_ptr entropy, char *bufstart,
+                    unsigned int nbits)
 {
  if (entropy->gather_statistics)
    return;                     /* no real work */

  while (nbits > 0) {
-    emit_bits(entropy, (unsigned int)(*bufstart), 1);
+    emit_bits(entropy, (unsigned int) (*bufstart), 1);
    bufstart++;
    nbits--;
  }
@@ -421,13 +314,15 @@ emit_buffered_bits(phuff_entropy_ptr entropy, char *bufstart,
 */

 LOCAL(void)
-emit_eobrun(phuff_entropy_ptr entropy)
+emit_eobrun (phuff_entropy_ptr entropy)
 {
  register int temp, nbits;

  if (entropy->EOBRUN > 0) {    /* if there is any pending EOBRUN */
    temp = entropy->EOBRUN;
-    nbits = JPEG_NBITS_NONZERO(temp) - 1;
+    nbits = 0;
+    while ((temp >>= 1))
+      nbits++;
    /* safety check: shouldn't happen given limited correction-bit buffer */
    if (nbits > 14)
      ERREXIT(entropy->cinfo, JERR_HUFF_MISSING_CODE);
@@ -450,13 +345,13 @@ emit_eobrun(phuff_entropy_ptr entropy)
 */

 LOCAL(void)
-emit_restart(phuff_entropy_ptr entropy, int restart_num)
+emit_restart (phuff_entropy_ptr entropy, int restart_num)
 {
  int ci;

  emit_eobrun(entropy);

-  if (!entropy->gather_statistics) {
+  if (! entropy->gather_statistics) {
    flush_bits(entropy);
    emit_byte(entropy, 0xFF);
    emit_byte(entropy, JPEG_RST0 + restart_num);
@@ -480,10 +375,10 @@ emit_restart(phuff_entropy_ptr entropy, int restart_num)
 */

 METHODDEF(boolean)
-encode_mcu_DC_first(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+encode_mcu_DC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
 {
-  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
-  register int temp, temp2, temp3;
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+  register int temp, temp2;
  register int nbits;
  int blkn, ci;
  int Al = cinfo->Al;
@@ -508,31 +403,31 @@ encode_mcu_DC_first(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
    /* Compute the DC value after the required point transform by Al.
     * This is simply an arithmetic right shift.
     */
-    temp2 = IRIGHT_SHIFT((int)((*block)[0]), Al);
+    temp2 = IRIGHT_SHIFT((int) ((*block)[0]), Al);

    /* DC differences are figured on the point-transformed values. */
    temp = temp2 - entropy->last_dc_val[ci];
    entropy->last_dc_val[ci] = temp2;

    /* Encode the DC coefficient difference per section G.1.2.1 */
-
-    /* This is a well-known technique for obtaining the absolute value without
-     * a branch.  It is derived from an assembly language technique presented
-     * in "How to Optimize for the Pentium Processors", Copyright (c) 1996,
-     * 1997 by Agner Fog.
-     */
-    temp3 = temp >> (CHAR_BIT * sizeof(int) - 1);
-    temp ^= temp3;
-    temp -= temp3;              /* temp is abs value of input */
-    /* For a negative input, want temp2 = bitwise complement of abs(input) */
-    temp2 = temp ^ temp3;
+    temp2 = temp;
+    if (temp < 0) {
+      temp = -temp;             /* temp is abs value of input */
+      /* For a negative input, want temp2 = bitwise complement of abs(input) */
+      /* This code assumes we are on a two's complement machine */
+      temp2--;
+    }

    /* Find the number of bits needed for the magnitude of the coefficient */
-    nbits = JPEG_NBITS(temp);
+    nbits = 0;
+    while (temp) {
+      nbits++;
+      temp >>= 1;
+    }
    /* Check for out-of-range coefficient values.
     * Since we're encoding a difference, the range limit is twice as much.
     */
-    if (nbits > MAX_COEF_BITS + 1)
+    if (nbits > MAX_COEF_BITS+1)
      ERREXIT(cinfo, JERR_BAD_DCT_COEF);

    /* Count/emit the Huffman-coded symbol for the number of bits */
@@ -541,7 +436,7 @@ encode_mcu_DC_first(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
    /* Emit that number of bits of the value, if positive, */
    /* or the complement of its magnitude, if negative. */
    if (nbits)                  /* emit_bits rejects calls with size 0 */
-      emit_bits(entropy, (unsigned int)temp2, nbits);
+      emit_bits(entropy, (unsigned int) temp2, nbits);
  }

  cinfo->dest->next_output_byte = entropy->next_output_byte;
@@ -561,116 +456,21 @@ encode_mcu_DC_first(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
 }


-/*
- * Data preparation for encode_mcu_AC_first().
- */
-
-#define COMPUTE_ABSVALUES_AC_FIRST(Sl) { \
-  for (k = 0; k < Sl; k++) { \
-    temp = block[jpeg_natural_order_start[k]]; \
-    if (temp == 0) \
-      continue; \
-    /* We must apply the point transform by Al.  For AC coefficients this \
-     * is an integer division with rounding towards 0.  To do this portably \
-     * in C, we shift after obtaining the absolute value; so the code is \
-     * interwoven with finding the abs value (temp) and output bits (temp2). \
-     */ \
-    temp2 = temp >> (CHAR_BIT * sizeof(int) - 1); \
-    temp ^= temp2; \
-    temp -= temp2;              /* temp is abs value of input */ \
-    temp >>= Al;                /* apply the point transform */ \
-    /* Watch out for case that nonzero coef is zero after point transform */ \
-    if (temp == 0) \
-      continue; \
-    /* For a negative coef, want temp2 = bitwise complement of abs(coef) */ \
-    temp2 ^= temp; \
-    values[k] = temp; \
-    values[k + DCTSIZE2] = temp2; \
-    zerobits |= ((size_t)1U) << k; \
-  } \
-}
-
-METHODDEF(void)
-encode_mcu_AC_first_prepare(const JCOEF *block,
-                            const int *jpeg_natural_order_start, int Sl,
-                            int Al, JCOEF *values, size_t *bits)
-{
-  register int k, temp, temp2;
-  size_t zerobits = 0U;
-  int Sl0 = Sl;
-
-#if SIZEOF_SIZE_T == 4
-  if (Sl0 > 32)
-    Sl0 = 32;
-#endif
-
-  COMPUTE_ABSVALUES_AC_FIRST(Sl0);
-
-  bits[0] = zerobits;
-#if SIZEOF_SIZE_T == 4
-  zerobits = 0U;
-
-  if (Sl > 32) {
-    Sl -= 32;
-    jpeg_natural_order_start += 32;
-    values += 32;
-
-    COMPUTE_ABSVALUES_AC_FIRST(Sl);
-  }
-  bits[1] = zerobits;
-#endif
-}
-
 /*
 * MCU encoding for AC initial scan (either spectral selection,
 * or first pass of successive approximation).
 */

-#define ENCODE_COEFS_AC_FIRST(label) { \
-  while (zerobits) { \
-    r = count_zeroes(&zerobits); \
-    cvalue += r; \
-label \
-    temp  = cvalue[0]; \
-    temp2 = cvalue[DCTSIZE2]; \
-    \
-    /* if run length > 15, must emit special run-length-16 codes (0xF0) */ \
-    while (r > 15) { \
-      emit_symbol(entropy, entropy->ac_tbl_no, 0xF0); \
-      r -= 16; \
-    } \
-    \
-    /* Find the number of bits needed for the magnitude of the coefficient */ \
-    nbits = JPEG_NBITS_NONZERO(temp);  /* there must be at least one 1 bit */ \
-    /* Check for out-of-range coefficient values */ \
-    if (nbits > MAX_COEF_BITS) \
-      ERREXIT(cinfo, JERR_BAD_DCT_COEF); \
-    \
-    /* Count/emit Huffman symbol for run length / number of bits */ \
-    emit_symbol(entropy, entropy->ac_tbl_no, (r << 4) + nbits); \
-    \
-    /* Emit that number of bits of the value, if positive, */ \
-    /* or the complement of its magnitude, if negative. */ \
-    emit_bits(entropy, (unsigned int)temp2, nbits); \
-    \
-    cvalue++; \
-    zerobits >>= 1; \
-  } \
-}
-
 METHODDEF(boolean)
-encode_mcu_AC_first(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+encode_mcu_AC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
 {
-  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
  register int temp, temp2;
-  register int nbits, r;
-  int Sl = cinfo->Se - cinfo->Ss + 1;
+  register int nbits;
+  register int r, k;
+  int Se = cinfo->Se;
  int Al = cinfo->Al;
-  JCOEF values_unaligned[2 * DCTSIZE2 + 15];
-  JCOEF *values;
-  const JCOEF *cvalue;
-  size_t zerobits;
-  size_t bits[8 / SIZEOF_SIZE_T];
+  JBLOCKROW block;

  entropy->next_output_byte = cinfo->dest->next_output_byte;
  entropy->free_in_buffer = cinfo->dest->free_in_buffer;
@@ -680,48 +480,66 @@ encode_mcu_AC_first(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
    if (entropy->restarts_to_go == 0)
      emit_restart(entropy, entropy->next_restart_num);

-#ifdef WITH_SIMD
-  cvalue = values = (JCOEF *)PAD((JUINTPTR)values_unaligned, 16);
-#else
-  /* Not using SIMD, so alignment is not needed */
-  cvalue = values = values_unaligned;
-#endif
-
-  /* Prepare data */
-  entropy->AC_first_prepare(MCU_data[0][0], jpeg_natural_order + cinfo->Ss,
-                            Sl, Al, values, bits);
-
-  zerobits = bits[0];
-#if SIZEOF_SIZE_T == 4
-  zerobits |= bits[1];
-#endif
-
-  /* Emit any pending EOBRUN */
-  if (zerobits && (entropy->EOBRUN > 0))
-    emit_eobrun(entropy);
-
-#if SIZEOF_SIZE_T == 4
-  zerobits = bits[0];
-#endif
+  /* Encode the MCU data block */
+  block = MCU_data[0];

  /* Encode the AC coefficients per section G.1.2.2, fig. G.3 */

-  ENCODE_COEFS_AC_FIRST((void)0;);
+  r = 0;                        /* r = run length of zeros */

-#if SIZEOF_SIZE_T == 4
-  zerobits = bits[1];
-  if (zerobits) {
-    int diff = ((values + DCTSIZE2 / 2) - cvalue);
-    r = count_zeroes(&zerobits);
-    r += diff;
-    cvalue += r;
-    goto first_iter_ac_first;
+  for (k = cinfo->Ss; k <= Se; k++) {
+    if ((temp = (*block)[jpeg_natural_order[k]]) == 0) {
+      r++;
+      continue;
+    }
+    /* We must apply the point transform by Al.  For AC coefficients this
+     * is an integer division with rounding towards 0.  To do this portably
+     * in C, we shift after obtaining the absolute value; so the code is
+     * interwoven with finding the abs value (temp) and output bits (temp2).
+     */
+    if (temp < 0) {
+      temp = -temp;             /* temp is abs value of input */
+      temp >>= Al;              /* apply the point transform */
+      /* For a negative coef, want temp2 = bitwise complement of abs(coef) */
+      temp2 = ~temp;
+    } else {
+      temp >>= Al;              /* apply the point transform */
+      temp2 = temp;
+    }
+    /* Watch out for case that nonzero coef is zero after point transform */
+    if (temp == 0) {
+      r++;
+      continue;
+    }
+
+    /* Emit any pending EOBRUN */
+    if (entropy->EOBRUN > 0)
+      emit_eobrun(entropy);
+    /* if run length > 15, must emit special run-length-16 codes (0xF0) */
+    while (r > 15) {
+      emit_symbol(entropy, entropy->ac_tbl_no, 0xF0);
+      r -= 16;
+    }
+
+    /* Find the number of bits needed for the magnitude of the coefficient */
+    nbits = 1;                  /* there must be at least one 1 bit */
+    while ((temp >>= 1))
+      nbits++;
+    /* Check for out-of-range coefficient values */
+    if (nbits > MAX_COEF_BITS)
+      ERREXIT(cinfo, JERR_BAD_DCT_COEF);
+
+    /* Count/emit Huffman symbol for run length / number of bits */
+    emit_symbol(entropy, entropy->ac_tbl_no, (r << 4) + nbits);
+
+    /* Emit that number of bits of the value, if positive, */
+    /* or the complement of its magnitude, if negative. */
+    emit_bits(entropy, (unsigned int) temp2, nbits);
+
+    r = 0;                      /* reset zero run length */
  }

-  ENCODE_COEFS_AC_FIRST(first_iter_ac_first:);
-#endif
-
-  if (cvalue < (values + Sl)) { /* If there are trailing zeroes, */
+  if (r > 0) {                  /* If there are trailing zeroes, */
    entropy->EOBRUN++;          /* count an EOB */
    if (entropy->EOBRUN == 0x7FFF)
      emit_eobrun(entropy);     /* force it out to avoid overflow */
@@ -751,9 +569,9 @@ encode_mcu_AC_first(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
 */

 METHODDEF(boolean)
-encode_mcu_DC_refine(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+encode_mcu_DC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
 {
-  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
  register int temp;
  int blkn;
  int Al = cinfo->Al;
@@ -773,7 +591,7 @@ encode_mcu_DC_refine(j_compress_ptr cinfo, JBLOCKROW *MCU_data)

    /* We simply emit the Al'th bit of the DC coefficient value. */
    temp = (*block)[0];
-    emit_bits(entropy, (unsigned int)(temp >> Al), 1);
+    emit_bits(entropy, (unsigned int) (temp >> Al), 1);
  }

  cinfo->dest->next_output_byte = entropy->next_output_byte;
@@ -793,149 +611,23 @@ encode_mcu_DC_refine(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
 }


-/*
- * Data preparation for encode_mcu_AC_refine().
- */
-
-#define COMPUTE_ABSVALUES_AC_REFINE(Sl, koffset) { \
-  /* It is convenient to make a pre-pass to determine the transformed \
-   * coefficients' absolute values and the EOB position. \
-   */ \
-  for (k = 0; k < Sl; k++) { \
-    temp = block[jpeg_natural_order_start[k]]; \
-    /* We must apply the point transform by Al.  For AC coefficients this \
-     * is an integer division with rounding towards 0.  To do this portably \
-     * in C, we shift after obtaining the absolute value. \
-     */ \
-    temp2 = temp >> (CHAR_BIT * sizeof(int) - 1); \
-    temp ^= temp2; \
-    temp -= temp2;              /* temp is abs value of input */ \
-    temp >>= Al;                /* apply the point transform */ \
-    if (temp != 0) { \
-      zerobits |= ((size_t)1U) << k; \
-      signbits |= ((size_t)(temp2 + 1)) << k; \
-    } \
-    absvalues[k] = (JCOEF)temp; /* save abs value for main pass */ \
-    if (temp == 1) \
-      EOB = k + koffset;        /* EOB = index of last newly-nonzero coef */ \
-  } \
-}
-
-METHODDEF(int)
-encode_mcu_AC_refine_prepare(const JCOEF *block,
-                             const int *jpeg_natural_order_start, int Sl,
-                             int Al, JCOEF *absvalues, size_t *bits)
-{
-  register int k, temp, temp2;
-  int EOB = 0;
-  size_t zerobits = 0U, signbits = 0U;
-  int Sl0 = Sl;
-
-#if SIZEOF_SIZE_T == 4
-  if (Sl0 > 32)
-    Sl0 = 32;
-#endif
-
-  COMPUTE_ABSVALUES_AC_REFINE(Sl0, 0);
-
-  bits[0] = zerobits;
-#if SIZEOF_SIZE_T == 8
-  bits[1] = signbits;
-#else
-  bits[2] = signbits;
-
-  zerobits = 0U;
-  signbits = 0U;
-
-  if (Sl > 32) {
-    Sl -= 32;
-    jpeg_natural_order_start += 32;
-    absvalues += 32;
-
-    COMPUTE_ABSVALUES_AC_REFINE(Sl, 32);
-  }
-
-  bits[1] = zerobits;
-  bits[3] = signbits;
-#endif
-
-  return EOB;
-}
-
-
 /*
 * MCU encoding for AC successive approximation refinement scan.
 */

-#define ENCODE_COEFS_AC_REFINE(label) { \
-  while (zerobits) { \
-    idx = count_zeroes(&zerobits); \
-    r += idx; \
-    cabsvalue += idx; \
-    signbits >>= idx; \
-label \
-    /* Emit any required ZRLs, but not if they can be folded into EOB */ \
-    while (r > 15 && (cabsvalue <= EOBPTR)) { \
-      /* emit any pending EOBRUN and the BE correction bits */ \
-      emit_eobrun(entropy); \
-      /* Emit ZRL */ \
-      emit_symbol(entropy, entropy->ac_tbl_no, 0xF0); \
-      r -= 16; \
-      /* Emit buffered correction bits that must be associated with ZRL */ \
-      emit_buffered_bits(entropy, BR_buffer, BR); \
-      BR_buffer = entropy->bit_buffer; /* BE bits are gone now */ \
-      BR = 0; \
-    } \
-    \
-    temp = *cabsvalue++; \
-    \
-    /* If the coef was previously nonzero, it only needs a correction bit. \
-     * NOTE: a straight translation of the spec's figure G.7 would suggest \
-     * that we also need to test r > 15.  But if r > 15, we can only get here \
-     * if k > EOB, which implies that this coefficient is not 1. \
-     */ \
-    if (temp > 1) { \
-      /* The correction bit is the next bit of the absolute value. */ \
-      BR_buffer[BR++] = (char)(temp & 1); \
-      signbits >>= 1; \
-      zerobits >>= 1; \
-      continue; \
-    } \
-    \
-    /* Emit any pending EOBRUN and the BE correction bits */ \
-    emit_eobrun(entropy); \
-    \
-    /* Count/emit Huffman symbol for run length / number of bits */ \
-    emit_symbol(entropy, entropy->ac_tbl_no, (r << 4) + 1); \
-    \
-    /* Emit output bit for newly-nonzero coef */ \
-    temp = signbits & 1; /* ((*block)[jpeg_natural_order_start[k]] < 0) ? 0 : 1 */ \
-    emit_bits(entropy, (unsigned int)temp, 1); \
-    \
-    /* Emit buffered correction bits that must be associated with this code */ \
-    emit_buffered_bits(entropy, BR_buffer, BR); \
-    BR_buffer = entropy->bit_buffer; /* BE bits are gone now */ \
-    BR = 0; \
-    r = 0;                      /* reset zero run length */ \
-    signbits >>= 1; \
-    zerobits >>= 1; \
-  } \
-}
-
 METHODDEF(boolean)
-encode_mcu_AC_refine(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+encode_mcu_AC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
 {
-  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
-  register int temp, r, idx;
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+  register int temp;
+  register int r, k;
+  int EOB;
  char *BR_buffer;
  unsigned int BR;
-  int Sl = cinfo->Se - cinfo->Ss + 1;
+  int Se = cinfo->Se;
  int Al = cinfo->Al;
-  JCOEF absvalues_unaligned[DCTSIZE2 + 15];
-  JCOEF *absvalues;
-  const JCOEF *cabsvalue, *EOBPTR;
-  size_t zerobits, signbits;
-  size_t bits[16 / SIZEOF_SIZE_T];
+  JBLOCKROW block;
+  int absvalues[DCTSIZE2];

  entropy->next_output_byte = cinfo->dest->next_output_byte;
  entropy->free_in_buffer = cinfo->dest->free_in_buffer;
@@ -945,17 +637,26 @@ encode_mcu_AC_refine(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
    if (entropy->restarts_to_go == 0)
      emit_restart(entropy, entropy->next_restart_num);

-#ifdef WITH_SIMD
-  cabsvalue = absvalues = (JCOEF *)PAD((JUINTPTR)absvalues_unaligned, 16);
-#else
-  /* Not using SIMD, so alignment is not needed */
-  cabsvalue = absvalues = absvalues_unaligned;
-#endif
+  /* Encode the MCU data block */
+  block = MCU_data[0];

-  /* Prepare data */
-  EOBPTR = absvalues +
-    entropy->AC_refine_prepare(MCU_data[0][0], jpeg_natural_order + cinfo->Ss,
-                               Sl, Al, absvalues, bits);
+  /* It is convenient to make a pre-pass to determine the transformed
+   * coefficients' absolute values and the EOB position.
+   */
+  EOB = 0;
+  for (k = cinfo->Ss; k <= Se; k++) {
+    temp = (*block)[jpeg_natural_order[k]];
+    /* We must apply the point transform by Al.  For AC coefficients this
+     * is an integer division with rounding towards 0.  To do this portably
+     * in C, we shift after obtaining the absolute value.
+     */
+    if (temp < 0)
+      temp = -temp;             /* temp is abs value of input */
+    temp >>= Al;                /* apply the point transform */
+    absvalues[k] = temp;        /* save abs value for main pass */
+    if (temp == 1)
+      EOB = k;                  /* EOB = index of last newly-nonzero coef */
+  }

  /* Encode the AC coefficients per section G.1.2.3, fig. G.7 */

@@ -963,33 +664,53 @@ encode_mcu_AC_refine(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
  BR = 0;                       /* BR = count of buffered bits added now */
  BR_buffer = entropy->bit_buffer + entropy->BE; /* Append bits to buffer */

-  zerobits = bits[0];
-#if SIZEOF_SIZE_T == 8
-  signbits = bits[1];
-#else
-  signbits = bits[2];
-#endif
-  ENCODE_COEFS_AC_REFINE((void)0;);
+  for (k = cinfo->Ss; k <= Se; k++) {
+    if ((temp = absvalues[k]) == 0) {
+      r++;
+      continue;
+    }

-#if SIZEOF_SIZE_T == 4
-  zerobits = bits[1];
-  signbits = bits[3];
+    /* Emit any required ZRLs, but not if they can be folded into EOB */
+    while (r > 15 && k <= EOB) {
+      /* emit any pending EOBRUN and the BE correction bits */
+      emit_eobrun(entropy);
+      /* Emit ZRL */
+      emit_symbol(entropy, entropy->ac_tbl_no, 0xF0);
+      r -= 16;
+      /* Emit buffered correction bits that must be associated with ZRL */
+      emit_buffered_bits(entropy, BR_buffer, BR);
+      BR_buffer = entropy->bit_buffer; /* BE bits are gone now */
+      BR = 0;
+    }

-  if (zerobits) {
-    int diff = ((absvalues + DCTSIZE2 / 2) - cabsvalue);
-    idx = count_zeroes(&zerobits);
-    signbits >>= idx;
-    idx += diff;
-    r += idx;
-    cabsvalue += idx;
-    goto first_iter_ac_refine;
+    /* If the coef was previously nonzero, it only needs a correction bit.
+     * NOTE: a straight translation of the spec's figure G.7 would suggest
+     * that we also need to test r > 15.  But if r > 15, we can only get here
+     * if k > EOB, which implies that this coefficient is not 1.
+     */
+    if (temp > 1) {
+      /* The correction bit is the next bit of the absolute value. */
+      BR_buffer[BR++] = (char) (temp & 1);
+      continue;
+    }
+
+    /* Emit any pending EOBRUN and the BE correction bits */
+    emit_eobrun(entropy);
+
+    /* Count/emit Huffman symbol for run length / number of bits */
+    emit_symbol(entropy, entropy->ac_tbl_no, (r << 4) + 1);
+
+    /* Emit output bit for newly-nonzero coef */
+    temp = ((*block)[jpeg_natural_order[k]] < 0) ? 0 : 1;
+    emit_bits(entropy, (unsigned int) temp, 1);
+
+    /* Emit buffered correction bits that must be associated with this code */
+    emit_buffered_bits(entropy, BR_buffer, BR);
+    BR_buffer = entropy->bit_buffer; /* BE bits are gone now */
+    BR = 0;
+    r = 0;                      /* reset zero run length */
  }

-  ENCODE_COEFS_AC_REFINE(first_iter_ac_refine:);
-#endif
-
-  r |= (int)((absvalues + Sl) - cabsvalue);
-
  if (r > 0 || BR > 0) {        /* If there are trailing zeroes, */
    entropy->EOBRUN++;          /* count an EOB */
    entropy->BE += BR;          /* concat my correction bits to older ones */
@@ -997,8 +718,7 @@ encode_mcu_AC_refine(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
     * 1. overflow of the EOB counter;
     * 2. overflow of the correction bit buffer during the next MCU.
     */
-    if (entropy->EOBRUN == 0x7FFF ||
-        entropy->BE > (MAX_CORR_BITS - DCTSIZE2 + 1))
+    if (entropy->EOBRUN == 0x7FFF || entropy->BE > (MAX_CORR_BITS-DCTSIZE2+1))
      emit_eobrun(entropy);
  }

@@ -1024,9 +744,9 @@ encode_mcu_AC_refine(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
 */

 METHODDEF(void)
-finish_pass_phuff(j_compress_ptr cinfo)
+finish_pass_phuff (j_compress_ptr cinfo)
 {
-  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;

  entropy->next_output_byte = cinfo->dest->next_output_byte;
  entropy->free_in_buffer = cinfo->dest->free_in_buffer;
@@ -1045,9 +765,9 @@ finish_pass_phuff(j_compress_ptr cinfo)
 */

 METHODDEF(void)
-finish_pass_gather_phuff(j_compress_ptr cinfo)
+finish_pass_gather_phuff (j_compress_ptr cinfo)
 {
-  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
  boolean is_DC_band;
  int ci, tbl;
  jpeg_component_info *compptr;
@@ -1073,13 +793,13 @@ finish_pass_gather_phuff(j_compress_ptr cinfo)
    } else {
      tbl = compptr->ac_tbl_no;
    }
-    if (!did[tbl]) {
+    if (! did[tbl]) {
      if (is_DC_band)
-        htblptr = &cinfo->dc_huff_tbl_ptrs[tbl];
+        htblptr = & cinfo->dc_huff_tbl_ptrs[tbl];
      else
-        htblptr = &cinfo->ac_huff_tbl_ptrs[tbl];
+        htblptr = & cinfo->ac_huff_tbl_ptrs[tbl];
      if (*htblptr == NULL)
-        *htblptr = jpeg_alloc_huff_table((j_common_ptr)cinfo);
+        *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
      jpeg_gen_optimal_table(cinfo, *htblptr, entropy->count_ptrs[tbl]);
      did[tbl] = TRUE;
    }
@@ -1092,15 +812,15 @@ finish_pass_gather_phuff(j_compress_ptr cinfo)
 */

 GLOBAL(void)
-jinit_phuff_encoder(j_compress_ptr cinfo)
+jinit_phuff_encoder (j_compress_ptr cinfo)
 {
  phuff_entropy_ptr entropy;
  int i;

  entropy = (phuff_entropy_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                sizeof(phuff_entropy_encoder));
-  cinfo->entropy = (struct jpeg_entropy_encoder *)entropy;
+  cinfo->entropy = (struct jpeg_entropy_encoder *) entropy;
  entropy->pub.start_pass = start_pass_phuff;

  /* Mark tables unallocated */
@@ -78,9 +78,9 @@ typedef my_prep_controller *my_prep_ptr;
 */

 METHODDEF(void)
-start_pass_prep(j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+start_pass_prep (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
 {
-  my_prep_ptr prep = (my_prep_ptr)cinfo->prep;
+  my_prep_ptr prep = (my_prep_ptr) cinfo->prep;

  if (pass_mode != JBUF_PASS_THRU)
    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
@@ -106,14 +106,14 @@ start_pass_prep(j_compress_ptr cinfo, J_BUF_MODE pass_mode)
 */

 LOCAL(void)
-expand_bottom_edge(JSAMPARRAY image_data, JDIMENSION num_cols, int input_rows,
-                   int output_rows)
+expand_bottom_edge (JSAMPARRAY image_data, JDIMENSION num_cols,
+                    int input_rows, int output_rows)
 {
  register int row;

  for (row = input_rows; row < output_rows; row++) {
-    jcopy_sample_rows(image_data, input_rows - 1, image_data, row, 1,
-                      num_cols);
+    jcopy_sample_rows(image_data, input_rows-1, image_data, row,
+                      1, num_cols);
  }
 }

@@ -128,12 +128,13 @@ expand_bottom_edge(JSAMPARRAY image_data, JDIMENSION num_cols, int input_rows,
 */

 METHODDEF(void)
-pre_process_data(j_compress_ptr cinfo, JSAMPARRAY input_buf,
-                 JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail,
-                 JSAMPIMAGE output_buf, JDIMENSION *out_row_group_ctr,
-                 JDIMENSION out_row_groups_avail)
+pre_process_data (j_compress_ptr cinfo,
+                  JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+                  JDIMENSION in_rows_avail,
+                  JSAMPIMAGE output_buf, JDIMENSION *out_row_group_ctr,
+                  JDIMENSION out_row_groups_avail)
 {
-  my_prep_ptr prep = (my_prep_ptr)cinfo->prep;
+  my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
  int numrows, ci;
  JDIMENSION inrows;
  jpeg_component_info *compptr;
@@ -143,10 +144,10 @@ pre_process_data(j_compress_ptr cinfo, JSAMPARRAY input_buf,
    /* Do color conversion to fill the conversion buffer. */
    inrows = in_rows_avail - *in_row_ctr;
    numrows = cinfo->max_v_samp_factor - prep->next_buf_row;
-    numrows = (int)MIN((JDIMENSION)numrows, inrows);
+    numrows = (int) MIN((JDIMENSION) numrows, inrows);
    (*cinfo->cconvert->color_convert) (cinfo, input_buf + *in_row_ctr,
                                       prep->color_buf,
-                                       (JDIMENSION)prep->next_buf_row,
+                                       (JDIMENSION) prep->next_buf_row,
                                       numrows);
    *in_row_ctr += numrows;
    prep->next_buf_row += numrows;
@@ -163,7 +164,7 @@ pre_process_data(j_compress_ptr cinfo, JSAMPARRAY input_buf,
    /* If we've filled the conversion buffer, empty it. */
    if (prep->next_buf_row == cinfo->max_v_samp_factor) {
      (*cinfo->downsample->downsample) (cinfo,
-                                        prep->color_buf, (JDIMENSION)0,
+                                        prep->color_buf, (JDIMENSION) 0,
                                        output_buf, *out_row_group_ctr);
      prep->next_buf_row = 0;
      (*out_row_group_ctr)++;
@@ -171,12 +172,14 @@ pre_process_data(j_compress_ptr cinfo, JSAMPARRAY input_buf,
    /* If at bottom of image, pad the output to a full iMCU height.
     * Note we assume the caller is providing a one-iMCU-height output buffer!
     */
-    if (prep->rows_to_go == 0 && *out_row_group_ctr < out_row_groups_avail) {
+    if (prep->rows_to_go == 0 &&
+        *out_row_group_ctr < out_row_groups_avail) {
      for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
           ci++, compptr++) {
-        expand_bottom_edge(output_buf[ci], compptr->width_in_blocks * DCTSIZE,
-                           (int)(*out_row_group_ctr * compptr->v_samp_factor),
-                           (int)(out_row_groups_avail * compptr->v_samp_factor));
+        expand_bottom_edge(output_buf[ci],
+                           compptr->width_in_blocks * DCTSIZE,
+                           (int) (*out_row_group_ctr * compptr->v_samp_factor),
+                           (int) (out_row_groups_avail * compptr->v_samp_factor));
      }
      *out_row_group_ctr = out_row_groups_avail;
      break;                    /* can exit outer loop without test */
@@ -192,12 +195,13 @@ pre_process_data(j_compress_ptr cinfo, JSAMPARRAY input_buf,
 */

 METHODDEF(void)
-pre_process_context(j_compress_ptr cinfo, JSAMPARRAY input_buf,
-                    JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail,
-                    JSAMPIMAGE output_buf, JDIMENSION *out_row_group_ctr,
-                    JDIMENSION out_row_groups_avail)
+pre_process_context (j_compress_ptr cinfo,
+                     JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+                     JDIMENSION in_rows_avail,
+                     JSAMPIMAGE output_buf, JDIMENSION *out_row_group_ctr,
+                     JDIMENSION out_row_groups_avail)
 {
-  my_prep_ptr prep = (my_prep_ptr)cinfo->prep;
+  my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
  int numrows, ci;
  int buf_height = cinfo->max_v_samp_factor * 3;
  JDIMENSION inrows;
@@ -207,18 +211,19 @@ pre_process_context(j_compress_ptr cinfo, JSAMPARRAY input_buf,
      /* Do color conversion to fill the conversion buffer. */
      inrows = in_rows_avail - *in_row_ctr;
      numrows = prep->next_buf_stop - prep->next_buf_row;
-      numrows = (int)MIN((JDIMENSION)numrows, inrows);
+      numrows = (int) MIN((JDIMENSION) numrows, inrows);
      (*cinfo->cconvert->color_convert) (cinfo, input_buf + *in_row_ctr,
                                         prep->color_buf,
-                                         (JDIMENSION)prep->next_buf_row,
+                                         (JDIMENSION) prep->next_buf_row,
                                         numrows);
      /* Pad at top of image, if first time through */
      if (prep->rows_to_go == cinfo->image_height) {
        for (ci = 0; ci < cinfo->num_components; ci++) {
          int row;
          for (row = 1; row <= cinfo->max_v_samp_factor; row++) {
-            jcopy_sample_rows(prep->color_buf[ci], 0, prep->color_buf[ci],
-                              -row, 1, cinfo->image_width);
+            jcopy_sample_rows(prep->color_buf[ci], 0,
+                              prep->color_buf[ci], -row,
+                              1, cinfo->image_width);
          }
        }
      }
@@ -240,8 +245,9 @@ pre_process_context(j_compress_ptr cinfo, JSAMPARRAY input_buf,
    }
    /* If we've gotten enough data, downsample a row group. */
    if (prep->next_buf_row == prep->next_buf_stop) {
-      (*cinfo->downsample->downsample) (cinfo, prep->color_buf,
-                                        (JDIMENSION)prep->this_row_group,
+      (*cinfo->downsample->downsample) (cinfo,
+                                        prep->color_buf,
+                                        (JDIMENSION) prep->this_row_group,
                                        output_buf, *out_row_group_ctr);
      (*out_row_group_ctr)++;
      /* Advance pointers with wraparound as necessary. */
@@ -261,9 +267,9 @@ pre_process_context(j_compress_ptr cinfo, JSAMPARRAY input_buf,
 */

 LOCAL(void)
-create_context_buffer(j_compress_ptr cinfo)
+create_context_buffer (j_compress_ptr cinfo)
 {
-  my_prep_ptr prep = (my_prep_ptr)cinfo->prep;
+  my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
  int rgroup_height = cinfo->max_v_samp_factor;
  int ci, i;
  jpeg_component_info *compptr;
@@ -273,7 +279,7 @@ create_context_buffer(j_compress_ptr cinfo)
   * we need five row groups' worth of pointers for each component.
   */
  fake_buffer = (JSAMPARRAY)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                (cinfo->num_components * 5 * rgroup_height) *
                                sizeof(JSAMPROW));

@@ -284,10 +290,10 @@ create_context_buffer(j_compress_ptr cinfo)
     * horizontally within the buffer, if it so chooses.
     */
    true_buffer = (*cinfo->mem->alloc_sarray)
-      ((j_common_ptr)cinfo, JPOOL_IMAGE,
-       (JDIMENSION)(((long)compptr->width_in_blocks * DCTSIZE *
-                     cinfo->max_h_samp_factor) / compptr->h_samp_factor),
-       (JDIMENSION)(3 * rgroup_height));
+      ((j_common_ptr) cinfo, JPOOL_IMAGE,
+       (JDIMENSION) (((long) compptr->width_in_blocks * DCTSIZE *
+                      cinfo->max_h_samp_factor) / compptr->h_samp_factor),
+       (JDIMENSION) (3 * rgroup_height));
    /* Copy true buffer row pointers into the middle of the fake row array */
    MEMCOPY(fake_buffer + rgroup_height, true_buffer,
            3 * rgroup_height * sizeof(JSAMPROW));
@@ -309,7 +315,7 @@ create_context_buffer(j_compress_ptr cinfo)
 */

 GLOBAL(void)
-jinit_c_prep_controller(j_compress_ptr cinfo, boolean need_full_buffer)
+jinit_c_prep_controller (j_compress_ptr cinfo, boolean need_full_buffer)
 {
  my_prep_ptr prep;
  int ci;
@@ -319,9 +325,9 @@ jinit_c_prep_controller(j_compress_ptr cinfo, boolean need_full_buffer)
    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);

  prep = (my_prep_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                sizeof(my_prep_controller));
-  cinfo->prep = (struct jpeg_c_prep_controller *)prep;
+  cinfo->prep = (struct jpeg_c_prep_controller *) prep;
  prep->pub.start_pass = start_pass_prep;

  /* Allocate the color conversion buffer.
@@ -342,10 +348,10 @@ jinit_c_prep_controller(j_compress_ptr cinfo, boolean need_full_buffer)
    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
         ci++, compptr++) {
      prep->color_buf[ci] = (*cinfo->mem->alloc_sarray)
-        ((j_common_ptr)cinfo, JPOOL_IMAGE,
-         (JDIMENSION)(((long)compptr->width_in_blocks * DCTSIZE *
-                       cinfo->max_h_samp_factor) / compptr->h_samp_factor),
-         (JDIMENSION)cinfo->max_v_samp_factor);
+        ((j_common_ptr) cinfo, JPOOL_IMAGE,
+         (JDIMENSION) (((long) compptr->width_in_blocks * DCTSIZE *
+                        cinfo->max_h_samp_factor) / compptr->h_samp_factor),
+         (JDIMENSION) cinfo->max_v_samp_factor);
    }
  }
 }
@@ -6,7 +6,7 @@
 * libjpeg-turbo Modifications:
 * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
 * Copyright (C) 2014, MIPS Technologies, Inc., California.
- * Copyright (C) 2015, 2019, D. R. Commander.
+ * Copyright (C) 2015, D. R. Commander.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
 *
@@ -79,7 +79,7 @@ typedef my_downsampler *my_downsample_ptr;
 */

 METHODDEF(void)
-start_pass_downsample(j_compress_ptr cinfo)
+start_pass_downsample (j_compress_ptr cinfo)
 {
  /* no work for now */
 }
@@ -91,19 +91,19 @@ start_pass_downsample(j_compress_ptr cinfo)
 */

 LOCAL(void)
-expand_right_edge(JSAMPARRAY image_data, int num_rows, JDIMENSION input_cols,
-                  JDIMENSION output_cols)
+expand_right_edge (JSAMPARRAY image_data, int num_rows,
+                   JDIMENSION input_cols, JDIMENSION output_cols)
 {
  register JSAMPROW ptr;
  register JSAMPLE pixval;
  register int count;
  int row;
-  int numcols = (int)(output_cols - input_cols);
+  int numcols = (int) (output_cols - input_cols);

  if (numcols > 0) {
    for (row = 0; row < num_rows; row++) {
      ptr = image_data[row] + input_cols;
-      pixval = ptr[-1];
+      pixval = ptr[-1];         /* don't need GETJSAMPLE() here */
      for (count = numcols; count > 0; count--)
        *ptr++ = pixval;
    }
@@ -118,11 +118,11 @@ expand_right_edge(JSAMPARRAY image_data, int num_rows, JDIMENSION input_cols,
 */

 METHODDEF(void)
-sep_downsample(j_compress_ptr cinfo, JSAMPIMAGE input_buf,
-               JDIMENSION in_row_index, JSAMPIMAGE output_buf,
-               JDIMENSION out_row_group_index)
+sep_downsample (j_compress_ptr cinfo,
+                JSAMPIMAGE input_buf, JDIMENSION in_row_index,
+                JSAMPIMAGE output_buf, JDIMENSION out_row_group_index)
 {
-  my_downsample_ptr downsample = (my_downsample_ptr)cinfo->downsample;
+  my_downsample_ptr downsample = (my_downsample_ptr) cinfo->downsample;
  int ci;
  jpeg_component_info *compptr;
  JSAMPARRAY in_ptr, out_ptr;
@@ -144,8 +144,8 @@ sep_downsample(j_compress_ptr cinfo, JSAMPIMAGE input_buf,
 */

 METHODDEF(void)
-int_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
-               JSAMPARRAY input_data, JSAMPARRAY output_data)
+int_downsample (j_compress_ptr cinfo, jpeg_component_info *compptr,
+                JSAMPARRAY input_data, JSAMPARRAY output_data)
 {
  int inrow, outrow, h_expand, v_expand, numpix, numpix2, h, v;
  JDIMENSION outcol, outcol_h;  /* outcol_h == outcol*h_expand */
@@ -156,14 +156,14 @@ int_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
  h_expand = cinfo->max_h_samp_factor / compptr->h_samp_factor;
  v_expand = cinfo->max_v_samp_factor / compptr->v_samp_factor;
  numpix = h_expand * v_expand;
-  numpix2 = numpix / 2;
+  numpix2 = numpix/2;

  /* Expand input data enough to let all the output samples be generated
   * by the standard loop.  Special-casing padded output would be more
   * efficient.
   */
-  expand_right_edge(input_data, cinfo->max_v_samp_factor, cinfo->image_width,
-                    output_cols * h_expand);
+  expand_right_edge(input_data, cinfo->max_v_samp_factor,
+                    cinfo->image_width, output_cols * h_expand);

  inrow = 0;
  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
@@ -172,12 +172,12 @@ int_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
         outcol++, outcol_h += h_expand) {
      outvalue = 0;
      for (v = 0; v < v_expand; v++) {
-        inptr = input_data[inrow + v] + outcol_h;
+        inptr = input_data[inrow+v] + outcol_h;
        for (h = 0; h < h_expand; h++) {
-          outvalue += (JLONG)(*inptr++);
+          outvalue += (JLONG) GETJSAMPLE(*inptr++);
        }
      }
-      *outptr++ = (JSAMPLE)((outvalue + numpix2) / numpix);
+      *outptr++ = (JSAMPLE) ((outvalue + numpix2) / numpix);
    }
    inrow += v_expand;
  }
@@ -191,15 +191,15 @@ int_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
 */

 METHODDEF(void)
-fullsize_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
-                    JSAMPARRAY input_data, JSAMPARRAY output_data)
+fullsize_downsample (j_compress_ptr cinfo, jpeg_component_info *compptr,
+                     JSAMPARRAY input_data, JSAMPARRAY output_data)
 {
  /* Copy the data */
-  jcopy_sample_rows(input_data, 0, output_data, 0, cinfo->max_v_samp_factor,
-                    cinfo->image_width);
+  jcopy_sample_rows(input_data, 0, output_data, 0,
+                    cinfo->max_v_samp_factor, cinfo->image_width);
  /* Edge-expand */
-  expand_right_edge(output_data, cinfo->max_v_samp_factor, cinfo->image_width,
-                    compptr->width_in_blocks * DCTSIZE);
+  expand_right_edge(output_data, cinfo->max_v_samp_factor,
+                    cinfo->image_width, compptr->width_in_blocks * DCTSIZE);
 }


@@ -216,8 +216,8 @@ fullsize_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
 */

 METHODDEF(void)
-h2v1_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
-                JSAMPARRAY input_data, JSAMPARRAY output_data)
+h2v1_downsample (j_compress_ptr cinfo, jpeg_component_info *compptr,
+                 JSAMPARRAY input_data, JSAMPARRAY output_data)
 {
  int outrow;
  JDIMENSION outcol;
@@ -229,15 +229,16 @@ h2v1_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
   * by the standard loop.  Special-casing padded output would be more
   * efficient.
   */
-  expand_right_edge(input_data, cinfo->max_v_samp_factor, cinfo->image_width,
-                    output_cols * 2);
+  expand_right_edge(input_data, cinfo->max_v_samp_factor,
+                    cinfo->image_width, output_cols * 2);

  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
    outptr = output_data[outrow];
    inptr = input_data[outrow];
    bias = 0;                   /* bias = 0,1,0,1,... for successive samples */
    for (outcol = 0; outcol < output_cols; outcol++) {
-      *outptr++ = (JSAMPLE)((inptr[0] + inptr[1] + bias) >> 1);
+      *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr) + GETJSAMPLE(inptr[1])
+                              + bias) >> 1);
      bias ^= 1;                /* 0=>1, 1=>0 */
      inptr += 2;
    }
@@ -252,8 +253,8 @@ h2v1_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
 */

 METHODDEF(void)
-h2v2_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
-                JSAMPARRAY input_data, JSAMPARRAY output_data)
+h2v2_downsample (j_compress_ptr cinfo, jpeg_component_info *compptr,
+                 JSAMPARRAY input_data, JSAMPARRAY output_data)
 {
  int inrow, outrow;
  JDIMENSION outcol;
@@ -265,20 +266,21 @@ h2v2_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
   * by the standard loop.  Special-casing padded output would be more
   * efficient.
   */
-  expand_right_edge(input_data, cinfo->max_v_samp_factor, cinfo->image_width,
-                    output_cols * 2);
+  expand_right_edge(input_data, cinfo->max_v_samp_factor,
+                    cinfo->image_width, output_cols * 2);

  inrow = 0;
  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
    outptr = output_data[outrow];
    inptr0 = input_data[inrow];
-    inptr1 = input_data[inrow + 1];
+    inptr1 = input_data[inrow+1];
    bias = 1;                   /* bias = 1,2,1,2,... for successive samples */
    for (outcol = 0; outcol < output_cols; outcol++) {
-      *outptr++ =
-        (JSAMPLE)((inptr0[0] + inptr0[1] + inptr1[0] + inptr1[1] + bias) >> 2);
+      *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
+                              GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1])
+                              + bias) >> 2);
      bias ^= 3;                /* 1=>2, 2=>1 */
-      inptr0 += 2;  inptr1 += 2;
+      inptr0 += 2; inptr1 += 2;
    }
    inrow += 2;
  }
@@ -294,8 +296,8 @@ h2v2_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
 */

 METHODDEF(void)
-h2v2_smooth_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
-                       JSAMPARRAY input_data, JSAMPARRAY output_data)
+h2v2_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info *compptr,
+                        JSAMPARRAY input_data, JSAMPARRAY output_data)
 {
  int inrow, outrow;
  JDIMENSION colctr;
@@ -330,45 +332,57 @@ h2v2_smooth_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
    outptr = output_data[outrow];
    inptr0 = input_data[inrow];
-    inptr1 = input_data[inrow + 1];
-    above_ptr = input_data[inrow - 1];
-    below_ptr = input_data[inrow + 2];
+    inptr1 = input_data[inrow+1];
+    above_ptr = input_data[inrow-1];
+    below_ptr = input_data[inrow+2];

    /* Special case for first column: pretend column -1 is same as column 0 */
-    membersum = inptr0[0] + inptr0[1] + inptr1[0] + inptr1[1];
-    neighsum = above_ptr[0] + above_ptr[1] + below_ptr[0] + below_ptr[1] +
-               inptr0[0] + inptr0[2] + inptr1[0] + inptr1[2];
+    membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
+                GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
+    neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
+               GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
+               GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[2]) +
+               GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[2]);
    neighsum += neighsum;
-    neighsum += above_ptr[0] + above_ptr[2] + below_ptr[0] + below_ptr[2];
+    neighsum += GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[2]) +
+                GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[2]);
    membersum = membersum * memberscale + neighsum * neighscale;
-    *outptr++ = (JSAMPLE)((membersum + 32768) >> 16);
-    inptr0 += 2;  inptr1 += 2;  above_ptr += 2;  below_ptr += 2;
+    *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
+    inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2;

    for (colctr = output_cols - 2; colctr > 0; colctr--) {
      /* sum of pixels directly mapped to this output element */
-      membersum = inptr0[0] + inptr0[1] + inptr1[0] + inptr1[1];
+      membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
+                  GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
      /* sum of edge-neighbor pixels */
-      neighsum = above_ptr[0] + above_ptr[1] + below_ptr[0] + below_ptr[1] +
-                 inptr0[-1] + inptr0[2] + inptr1[-1] + inptr1[2];
+      neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
+                 GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
+                 GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[2]) +
+                 GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[2]);
      /* The edge-neighbors count twice as much as corner-neighbors */
      neighsum += neighsum;
      /* Add in the corner-neighbors */
-      neighsum += above_ptr[-1] + above_ptr[2] + below_ptr[-1] + below_ptr[2];
+      neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[2]) +
+                  GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[2]);
      /* form final output scaled up by 2^16 */
      membersum = membersum * memberscale + neighsum * neighscale;
      /* round, descale and output it */
-      *outptr++ = (JSAMPLE)((membersum + 32768) >> 16);
-      inptr0 += 2;  inptr1 += 2;  above_ptr += 2;  below_ptr += 2;
+      *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
+      inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2;
    }

    /* Special case for last column */
-    membersum = inptr0[0] + inptr0[1] + inptr1[0] + inptr1[1];
-    neighsum = above_ptr[0] + above_ptr[1] + below_ptr[0] + below_ptr[1] +
-               inptr0[-1] + inptr0[1] + inptr1[-1] + inptr1[1];
+    membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
+                GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
+    neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
+               GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
+               GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[1]) +
+               GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[1]);
    neighsum += neighsum;
-    neighsum += above_ptr[-1] + above_ptr[1] + below_ptr[-1] + below_ptr[1];
+    neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[1]) +
+                GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[1]);
    membersum = membersum * memberscale + neighsum * neighscale;
-    *outptr = (JSAMPLE)((membersum + 32768) >> 16);
+    *outptr = (JSAMPLE) ((membersum + 32768) >> 16);

    inrow += 2;
  }
@@ -382,8 +396,8 @@ h2v2_smooth_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
 */

 METHODDEF(void)
-fullsize_smooth_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
-                           JSAMPARRAY input_data, JSAMPARRAY output_data)
+fullsize_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info *compptr,
+                            JSAMPARRAY input_data, JSAMPARRAY output_data)
 {
  int outrow;
  JDIMENSION colctr;
@@ -411,33 +425,36 @@ fullsize_smooth_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
    outptr = output_data[outrow];
    inptr = input_data[outrow];
-    above_ptr = input_data[outrow - 1];
-    below_ptr = input_data[outrow + 1];
+    above_ptr = input_data[outrow-1];
+    below_ptr = input_data[outrow+1];

    /* Special case for first column */
-    colsum = (*above_ptr++) + (*below_ptr++) + inptr[0];
-    membersum = *inptr++;
-    nextcolsum = above_ptr[0] + below_ptr[0] + inptr[0];
+    colsum = GETJSAMPLE(*above_ptr++) + GETJSAMPLE(*below_ptr++) +
+             GETJSAMPLE(*inptr);
+    membersum = GETJSAMPLE(*inptr++);
+    nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) +
+                 GETJSAMPLE(*inptr);
    neighsum = colsum + (colsum - membersum) + nextcolsum;
    membersum = membersum * memberscale + neighsum * neighscale;
-    *outptr++ = (JSAMPLE)((membersum + 32768) >> 16);
-    lastcolsum = colsum;  colsum = nextcolsum;
+    *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
+    lastcolsum = colsum; colsum = nextcolsum;

    for (colctr = output_cols - 2; colctr > 0; colctr--) {
-      membersum = *inptr++;
-      above_ptr++;  below_ptr++;
-      nextcolsum = above_ptr[0] + below_ptr[0] + inptr[0];
+      membersum = GETJSAMPLE(*inptr++);
+      above_ptr++; below_ptr++;
+      nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) +
+                   GETJSAMPLE(*inptr);
      neighsum = lastcolsum + (colsum - membersum) + nextcolsum;
      membersum = membersum * memberscale + neighsum * neighscale;
-      *outptr++ = (JSAMPLE)((membersum + 32768) >> 16);
-      lastcolsum = colsum;  colsum = nextcolsum;
+      *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
+      lastcolsum = colsum; colsum = nextcolsum;
    }

    /* Special case for last column */
-    membersum = *inptr;
+    membersum = GETJSAMPLE(*inptr);
    neighsum = lastcolsum + (colsum - membersum) + colsum;
    membersum = membersum * memberscale + neighsum * neighscale;
-    *outptr = (JSAMPLE)((membersum + 32768) >> 16);
+    *outptr = (JSAMPLE) ((membersum + 32768) >> 16);

  }
 }
@@ -451,7 +468,7 @@ fullsize_smooth_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
 */

 GLOBAL(void)
-jinit_downsampler(j_compress_ptr cinfo)
+jinit_downsampler (j_compress_ptr cinfo)
 {
  my_downsample_ptr downsample;
  int ci;
@@ -459,9 +476,9 @@ jinit_downsampler(j_compress_ptr cinfo)
  boolean smoothok = TRUE;

  downsample = (my_downsample_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                sizeof(my_downsampler));
-  cinfo->downsample = (struct jpeg_downsampler *)downsample;
+  cinfo->downsample = (struct jpeg_downsampler *) downsample;
  downsample->pub.start_pass = start_pass_downsample;
  downsample->pub.downsample = sep_downsample;
  downsample->pub.need_context_rows = FALSE;
@@ -4,8 +4,8 @@
 * This file was part of the Independent JPEG Group's software:
 * Copyright (C) 1995-1998, Thomas G. Lane.
 * Modified 2000-2009 by Guido Vollbeding.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2020, D. R. Commander.
+ * It was modified by The libjpeg-turbo Project to include only code relevant
+ * to libjpeg-turbo.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
 *
@@ -17,14 +17,13 @@
 #define JPEG_INTERNALS
 #include "jinclude.h"
 #include "jpeglib.h"
-#include "jpegcomp.h"


 /* Forward declarations */
-LOCAL(void) transencode_master_selection(j_compress_ptr cinfo,
-                                         jvirt_barray_ptr *coef_arrays);
-LOCAL(void) transencode_coef_controller(j_compress_ptr cinfo,
-                                        jvirt_barray_ptr *coef_arrays);
+LOCAL(void) transencode_master_selection
+        (j_compress_ptr cinfo, jvirt_barray_ptr *coef_arrays);
+LOCAL(void) transencode_coef_controller
+        (j_compress_ptr cinfo, jvirt_barray_ptr *coef_arrays);


 /*
@@ -40,14 +39,14 @@ LOCAL(void) transencode_coef_controller(j_compress_ptr cinfo,
 */

 GLOBAL(void)
-jpeg_write_coefficients(j_compress_ptr cinfo, jvirt_barray_ptr *coef_arrays)
+jpeg_write_coefficients (j_compress_ptr cinfo, jvirt_barray_ptr *coef_arrays)
 {
  if (cinfo->global_state != CSTATE_START)
    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
  /* Mark all tables to be written */
  jpeg_suppress_tables(cinfo, FALSE);
  /* (Re)initialize error mgr and destination modules */
-  (*cinfo->err->reset_error_mgr) ((j_common_ptr)cinfo);
+  (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
  (*cinfo->dest->init_destination) (cinfo);
  /* Perform master selection of active modules */
  transencode_master_selection(cinfo, coef_arrays);
@@ -65,7 +64,8 @@ jpeg_write_coefficients(j_compress_ptr cinfo, jvirt_barray_ptr *coef_arrays)
 */

 GLOBAL(void)
-jpeg_copy_critical_parameters(j_decompress_ptr srcinfo, j_compress_ptr dstinfo)
+jpeg_copy_critical_parameters (j_decompress_ptr srcinfo,
+                               j_compress_ptr dstinfo)
 {
  JQUANT_TBL **qtblptr;
  jpeg_component_info *incomp, *outcomp;
@@ -97,10 +97,11 @@ jpeg_copy_critical_parameters(j_decompress_ptr srcinfo, j_compress_ptr dstinfo)
  /* Copy the source's quantization tables. */
  for (tblno = 0; tblno < NUM_QUANT_TBLS; tblno++) {
    if (srcinfo->quant_tbl_ptrs[tblno] != NULL) {
-      qtblptr = &dstinfo->quant_tbl_ptrs[tblno];
+      qtblptr = & dstinfo->quant_tbl_ptrs[tblno];
      if (*qtblptr == NULL)
-        *qtblptr = jpeg_alloc_quant_table((j_common_ptr)dstinfo);
-      MEMCOPY((*qtblptr)->quantval, srcinfo->quant_tbl_ptrs[tblno]->quantval,
+        *qtblptr = jpeg_alloc_quant_table((j_common_ptr) dstinfo);
+      MEMCOPY((*qtblptr)->quantval,
+              srcinfo->quant_tbl_ptrs[tblno]->quantval,
              sizeof((*qtblptr)->quantval));
      (*qtblptr)->sent_table = FALSE;
    }
@@ -164,8 +165,8 @@ jpeg_copy_critical_parameters(j_decompress_ptr srcinfo, j_compress_ptr dstinfo)
 */

 LOCAL(void)
-transencode_master_selection(j_compress_ptr cinfo,
-                             jvirt_barray_ptr *coef_arrays)
+transencode_master_selection (j_compress_ptr cinfo,
+                              jvirt_barray_ptr *coef_arrays)
 {
  /* Although we don't actually use input_components for transcoding,
   * jcmaster.c's initial_setup will complain if input_components is 0.
@@ -198,7 +199,7 @@ transencode_master_selection(j_compress_ptr cinfo,
  jinit_marker_writer(cinfo);

  /* We can now tell the memory manager to allocate virtual arrays. */
-  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr)cinfo);
+  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);

  /* Write the datastream header (SOI, JFIF) immediately.
   * Frame and scan headers are postponed till later.
@@ -237,10 +238,10 @@ typedef my_coef_controller *my_coef_ptr;


 LOCAL(void)
-start_iMCU_row(j_compress_ptr cinfo)
+start_iMCU_row (j_compress_ptr cinfo)
 /* Reset within-iMCU-row counters for a new row */
 {
-  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;

  /* In an interleaved scan, an MCU row is the same as an iMCU row.
   * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
@@ -249,7 +250,7 @@ start_iMCU_row(j_compress_ptr cinfo)
  if (cinfo->comps_in_scan > 1) {
    coef->MCU_rows_per_iMCU_row = 1;
  } else {
-    if (coef->iMCU_row_num < (cinfo->total_iMCU_rows - 1))
+    if (coef->iMCU_row_num < (cinfo->total_iMCU_rows-1))
      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
    else
      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
@@ -265,9 +266,9 @@ start_iMCU_row(j_compress_ptr cinfo)
 */

 METHODDEF(void)
-start_pass_coef(j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+start_pass_coef (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
 {
-  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;

  if (pass_mode != JBUF_CRANK_DEST)
    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
@@ -288,9 +289,9 @@ start_pass_coef(j_compress_ptr cinfo, J_BUF_MODE pass_mode)
 */

 METHODDEF(boolean)
-compress_output(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
 {
-  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
  JDIMENSION MCU_col_num;       /* index of current MCU within row */
  JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
@@ -305,9 +306,9 @@ compress_output(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
    compptr = cinfo->cur_comp_info[ci];
    buffer[ci] = (*cinfo->mem->access_virt_barray)
-      ((j_common_ptr)cinfo, coef->whole_image[compptr->component_index],
+      ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index],
       coef->iMCU_row_num * compptr->v_samp_factor,
-       (JDIMENSION)compptr->v_samp_factor, FALSE);
+       (JDIMENSION) compptr->v_samp_factor, FALSE);
  }

  /* Loop to process one whole iMCU row */
@@ -320,13 +321,13 @@ compress_output(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
        compptr = cinfo->cur_comp_info[ci];
        start_col = MCU_col_num * compptr->MCU_width;
-        blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width :
-                                                  compptr->last_col_width;
+        blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
+                                                : compptr->last_col_width;
        for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
          if (coef->iMCU_row_num < last_iMCU_row ||
-              yindex + yoffset < compptr->last_row_height) {
+              yindex+yoffset < compptr->last_row_height) {
            /* Fill in pointers to real blocks in this row */
-            buffer_ptr = buffer[ci][yindex + yoffset] + start_col;
+            buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
            for (xindex = 0; xindex < blockcnt; xindex++)
              MCU_buffer[blkn++] = buffer_ptr++;
          } else {
@@ -341,13 +342,13 @@ compress_output(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
           */
          for (; xindex < compptr->MCU_width; xindex++) {
            MCU_buffer[blkn] = coef->dummy_buffer[blkn];
-            MCU_buffer[blkn][0][0] = MCU_buffer[blkn - 1][0][0];
+            MCU_buffer[blkn][0][0] = MCU_buffer[blkn-1][0][0];
            blkn++;
          }
        }
      }
      /* Try to write the MCU. */
-      if (!(*cinfo->entropy->encode_mcu) (cinfo, MCU_buffer)) {
+      if (! (*cinfo->entropy->encode_mcu) (cinfo, MCU_buffer)) {
        /* Suspension forced; update state counters and exit */
        coef->MCU_vert_offset = yoffset;
        coef->mcu_ctr = MCU_col_num;
@@ -373,17 +374,17 @@ compress_output(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
 */

 LOCAL(void)
-transencode_coef_controller(j_compress_ptr cinfo,
-                            jvirt_barray_ptr *coef_arrays)
+transencode_coef_controller (j_compress_ptr cinfo,
+                             jvirt_barray_ptr *coef_arrays)
 {
  my_coef_ptr coef;
  JBLOCKROW buffer;
  int i;

  coef = (my_coef_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                sizeof(my_coef_controller));
-  cinfo->coef = (struct jpeg_c_coef_controller *)coef;
+  cinfo->coef = (struct jpeg_c_coef_controller *) coef;
  coef->pub.start_pass = start_pass_coef;
  coef->pub.compress_data = compress_output;

@@ -392,9 +393,9 @@ transencode_coef_controller(j_compress_ptr cinfo,

  /* Allocate and pre-zero space for dummy DCT blocks. */
  buffer = (JBLOCKROW)
-    (*cinfo->mem->alloc_large) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+    (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                C_MAX_BLOCKS_IN_MCU * sizeof(JBLOCK));
-  jzero_far((void *)buffer, C_MAX_BLOCKS_IN_MCU * sizeof(JBLOCK));
+  jzero_far((void *) buffer, C_MAX_BLOCKS_IN_MCU * sizeof(JBLOCK));
  for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
    coef->dummy_buffer[i] = buffer + i;
  }
@@ -23,7 +23,6 @@
 #include "jinclude.h"
 #include "jpeglib.h"
 #include "jdmaster.h"
-#include "jconfigint.h"


 /*
@@ -32,7 +31,7 @@
 */

 GLOBAL(void)
-jpeg_CreateDecompress(j_decompress_ptr cinfo, int version, size_t structsize)
+jpeg_CreateDecompress (j_decompress_ptr cinfo, int version, size_t structsize)
 {
  int i;

@@ -42,7 +41,7 @@ jpeg_CreateDecompress(j_decompress_ptr cinfo, int version, size_t structsize)
    ERREXIT2(cinfo, JERR_BAD_LIB_VERSION, JPEG_LIB_VERSION, version);
  if (structsize != sizeof(struct jpeg_decompress_struct))
    ERREXIT2(cinfo, JERR_BAD_STRUCT_SIZE,
-             (int)sizeof(struct jpeg_decompress_struct), (int)structsize);
+             (int) sizeof(struct jpeg_decompress_struct), (int) structsize);

  /* For debugging purposes, we zero the whole master structure.
   * But the application has already set the err pointer, and may have set
@@ -51,8 +50,8 @@ jpeg_CreateDecompress(j_decompress_ptr cinfo, int version, size_t structsize)
   * complain here.
   */
  {
-    struct jpeg_error_mgr *err = cinfo->err;
-    void *client_data = cinfo->client_data; /* ignore Purify complaint here */
+    struct jpeg_error_mgr * err = cinfo->err;
+    void * client_data = cinfo->client_data; /* ignore Purify complaint here */
    MEMZERO(cinfo, sizeof(struct jpeg_decompress_struct));
    cinfo->err = err;
    cinfo->client_data = client_data;
@@ -60,7 +59,7 @@ jpeg_CreateDecompress(j_decompress_ptr cinfo, int version, size_t structsize)
  cinfo->is_decompressor = TRUE;

  /* Initialize a memory manager instance for this object */
-  jinit_memory_mgr((j_common_ptr)cinfo);
+  jinit_memory_mgr((j_common_ptr) cinfo);

  /* Zero out pointers to permanent structures. */
  cinfo->progress = NULL;
@@ -90,8 +89,8 @@ jpeg_CreateDecompress(j_decompress_ptr cinfo, int version, size_t structsize)
   * here.
   */
  cinfo->master = (struct jpeg_decomp_master *)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
-                                sizeof(my_decomp_master));
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+                                  sizeof(my_decomp_master));
  MEMZERO(cinfo->master, sizeof(my_decomp_master));
 }

@@ -101,9 +100,9 @@ jpeg_CreateDecompress(j_decompress_ptr cinfo, int version, size_t structsize)
 */

 GLOBAL(void)
-jpeg_destroy_decompress(j_decompress_ptr cinfo)
+jpeg_destroy_decompress (j_decompress_ptr cinfo)
 {
-  jpeg_destroy((j_common_ptr)cinfo); /* use common routine */
+  jpeg_destroy((j_common_ptr) cinfo); /* use common routine */
 }


@@ -113,9 +112,9 @@ jpeg_destroy_decompress(j_decompress_ptr cinfo)
 */

 GLOBAL(void)
-jpeg_abort_decompress(j_decompress_ptr cinfo)
+jpeg_abort_decompress (j_decompress_ptr cinfo)
 {
-  jpeg_abort((j_common_ptr)cinfo); /* use common routine */
+  jpeg_abort((j_common_ptr) cinfo); /* use common routine */
 }


@@ -124,7 +123,7 @@ jpeg_abort_decompress(j_decompress_ptr cinfo)
 */

 LOCAL(void)
-default_decompress_parms(j_decompress_ptr cinfo)
+default_decompress_parms (j_decompress_ptr cinfo)
 {
  /* Guess the input colorspace, and set output colorspace accordingly. */
  /* (Wish JPEG committee had provided a real way to specify this...) */
@@ -251,7 +250,7 @@ default_decompress_parms(j_decompress_ptr cinfo)
 */

 GLOBAL(int)
-jpeg_read_header(j_decompress_ptr cinfo, boolean require_image)
+jpeg_read_header (j_decompress_ptr cinfo, boolean require_image)
 {
  int retcode;

@@ -272,7 +271,7 @@ jpeg_read_header(j_decompress_ptr cinfo, boolean require_image)
     * call jpeg_abort, but we can't change it now for compatibility reasons.
     * A side effect is to free any temporary memory (there shouldn't be any).
     */
-    jpeg_abort((j_common_ptr)cinfo); /* sets state = DSTATE_START */
+    jpeg_abort((j_common_ptr) cinfo); /* sets state = DSTATE_START */
    retcode = JPEG_HEADER_TABLES_ONLY;
    break;
  case JPEG_SUSPENDED:
@@ -297,7 +296,7 @@ jpeg_read_header(j_decompress_ptr cinfo, boolean require_image)
 */

 GLOBAL(int)
-jpeg_consume_input(j_decompress_ptr cinfo)
+jpeg_consume_input (j_decompress_ptr cinfo)
 {
  int retcode = JPEG_SUSPENDED;

@@ -309,7 +308,7 @@ jpeg_consume_input(j_decompress_ptr cinfo)
    /* Initialize application's data source module */
    (*cinfo->src->init_source) (cinfo);
    cinfo->global_state = DSTATE_INHEADER;
-    FALLTHROUGH                 /*FALLTHROUGH*/
+    /*FALLTHROUGH*/
  case DSTATE_INHEADER:
    retcode = (*cinfo->inputctl->consume_input) (cinfo);
    if (retcode == JPEG_REACHED_SOS) { /* Found SOS, prepare to decompress */
@@ -344,7 +343,7 @@ jpeg_consume_input(j_decompress_ptr cinfo)
 */

 GLOBAL(boolean)
-jpeg_input_complete(j_decompress_ptr cinfo)
+jpeg_input_complete (j_decompress_ptr cinfo)
 {
  /* Check for valid jpeg object */
  if (cinfo->global_state < DSTATE_START ||
@@ -359,7 +358,7 @@ jpeg_input_complete(j_decompress_ptr cinfo)
 */

 GLOBAL(boolean)
-jpeg_has_multiple_scans(j_decompress_ptr cinfo)
+jpeg_has_multiple_scans (j_decompress_ptr cinfo)
 {
  /* Only valid after jpeg_read_header completes */
  if (cinfo->global_state < DSTATE_READY ||
@@ -379,10 +378,10 @@ jpeg_has_multiple_scans(j_decompress_ptr cinfo)
 */

 GLOBAL(boolean)
-jpeg_finish_decompress(j_decompress_ptr cinfo)
+jpeg_finish_decompress (j_decompress_ptr cinfo)
 {
  if ((cinfo->global_state == DSTATE_SCANNING ||
-       cinfo->global_state == DSTATE_RAW_OK) && !cinfo->buffered_image) {
+       cinfo->global_state == DSTATE_RAW_OK) && ! cinfo->buffered_image) {
    /* Terminate final pass of non-buffered mode */
    if (cinfo->output_scanline < cinfo->output_height)
      ERREXIT(cinfo, JERR_TOO_LITTLE_DATA);
@@ -396,13 +395,13 @@ jpeg_finish_decompress(j_decompress_ptr cinfo)
    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
  }
  /* Read until EOI */
-  while (!cinfo->inputctl->eoi_reached) {
+  while (! cinfo->inputctl->eoi_reached) {
    if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)
      return FALSE;             /* Suspend, come back later */
  }
  /* Do final cleanup */
  (*cinfo->src->term_source) (cinfo);
  /* We can use jpeg_abort to release memory and reset global_state */
-  jpeg_abort((j_common_ptr)cinfo);
+  jpeg_abort((j_common_ptr) cinfo);
  return TRUE;
 }
@@ -4,7 +4,7 @@
 * This file was part of the Independent JPEG Group's software:
 * Copyright (C) 1994-1996, Thomas G. Lane.
 * libjpeg-turbo Modifications:
- * Copyright (C) 2010, 2015-2020, D. R. Commander.
+ * Copyright (C) 2010, 2015-2017, D. R. Commander.
 * Copyright (C) 2015, Google, Inc.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
@@ -21,13 +21,11 @@
 #include "jinclude.h"
 #include "jdmainct.h"
 #include "jdcoefct.h"
-#include "jdmaster.h"
-#include "jdmerge.h"
 #include "jdsample.h"
 #include "jmemsys.h"

 /* Forward declarations */
-LOCAL(boolean) output_pass_setup(j_decompress_ptr cinfo);
+LOCAL(boolean) output_pass_setup (j_decompress_ptr cinfo);


 /*
@@ -42,7 +40,7 @@ LOCAL(boolean) output_pass_setup(j_decompress_ptr cinfo);
 */

 GLOBAL(boolean)
-jpeg_start_decompress(j_decompress_ptr cinfo)
+jpeg_start_decompress (j_decompress_ptr cinfo)
 {
  if (cinfo->global_state == DSTATE_READY) {
    /* First call: initialize master control, select active modules */
@@ -62,7 +60,7 @@ jpeg_start_decompress(j_decompress_ptr cinfo)
        int retcode;
        /* Call progress monitor hook if present */
        if (cinfo->progress != NULL)
-          (*cinfo->progress->progress_monitor) ((j_common_ptr)cinfo);
+          (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
        /* Absorb some more input */
        retcode = (*cinfo->inputctl->consume_input) (cinfo);
        if (retcode == JPEG_SUSPENDED)
@@ -74,7 +72,7 @@ jpeg_start_decompress(j_decompress_ptr cinfo)
            (retcode == JPEG_ROW_COMPLETED || retcode == JPEG_REACHED_SOS)) {
          if (++cinfo->progress->pass_counter >= cinfo->progress->pass_limit) {
            /* jdmaster underestimated number of scans; ratchet up one scan */
-            cinfo->progress->pass_limit += (long)cinfo->total_iMCU_rows;
+            cinfo->progress->pass_limit += (long) cinfo->total_iMCU_rows;
          }
        }
      }
@@ -99,7 +97,7 @@ jpeg_start_decompress(j_decompress_ptr cinfo)
 */

 LOCAL(boolean)
-output_pass_setup(j_decompress_ptr cinfo)
+output_pass_setup (j_decompress_ptr cinfo)
 {
  if (cinfo->global_state != DSTATE_PRESCAN) {
    /* First call: do pass setup */
@@ -115,14 +113,14 @@ output_pass_setup(j_decompress_ptr cinfo)
      JDIMENSION last_scanline;
      /* Call progress monitor hook if present */
      if (cinfo->progress != NULL) {
-        cinfo->progress->pass_counter = (long)cinfo->output_scanline;
-        cinfo->progress->pass_limit = (long)cinfo->output_height;
-        (*cinfo->progress->progress_monitor) ((j_common_ptr)cinfo);
+        cinfo->progress->pass_counter = (long) cinfo->output_scanline;
+        cinfo->progress->pass_limit = (long) cinfo->output_height;
+        (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
      }
      /* Process some data */
      last_scanline = cinfo->output_scanline;
-      (*cinfo->main->process_data) (cinfo, (JSAMPARRAY)NULL,
-                                    &cinfo->output_scanline, (JDIMENSION)0);
+      (*cinfo->main->process_data) (cinfo, (JSAMPARRAY) NULL,
+                                    &cinfo->output_scanline, (JDIMENSION) 0);
      if (cinfo->output_scanline == last_scanline)
        return FALSE;           /* No progress made, must suspend */
    }
@@ -152,8 +150,8 @@ output_pass_setup(j_decompress_ptr cinfo)
 */

 GLOBAL(void)
-jpeg_crop_scanline(j_decompress_ptr cinfo, JDIMENSION *xoffset,
-                   JDIMENSION *width)
+jpeg_crop_scanline (j_decompress_ptr cinfo, JDIMENSION *xoffset,
+                    JDIMENSION *width)
 {
  int ci, align, orig_downsampled_width;
  JDIMENSION input_xoffset;
@@ -212,10 +210,11 @@ jpeg_crop_scanline(j_decompress_ptr cinfo, JDIMENSION *xoffset,
  /* Set the first and last iMCU columns that we must decompress.  These values
   * will be used in single-scan decompressions.
   */
-  cinfo->master->first_iMCU_col = (JDIMENSION)(long)(*xoffset) / (long)align;
+  cinfo->master->first_iMCU_col =
+    (JDIMENSION) (long) (*xoffset) / (long) align;
  cinfo->master->last_iMCU_col =
-    (JDIMENSION)jdiv_round_up((long)(*xoffset + cinfo->output_width),
-                              (long)align) - 1;
+    (JDIMENSION) jdiv_round_up((long) (*xoffset + cinfo->output_width),
+                               (long) align) - 1;

  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
       ci++, compptr++) {
@@ -225,9 +224,9 @@ jpeg_crop_scanline(j_decompress_ptr cinfo, JDIMENSION *xoffset,
    /* Set downsampled_width to the new output width. */
    orig_downsampled_width = compptr->downsampled_width;
    compptr->downsampled_width =
-      (JDIMENSION)jdiv_round_up((long)(cinfo->output_width *
-                                       compptr->h_samp_factor),
-                                (long)cinfo->max_h_samp_factor);
+      (JDIMENSION) jdiv_round_up((long) (cinfo->output_width *
+                                         compptr->h_samp_factor),
+                                 (long) cinfo->max_h_samp_factor);
    if (compptr->downsampled_width < 2 && orig_downsampled_width >= 2)
      reinit_upsampler = TRUE;

@@ -235,10 +234,11 @@ jpeg_crop_scanline(j_decompress_ptr cinfo, JDIMENSION *xoffset,
     * values will be used in multi-scan decompressions.
     */
    cinfo->master->first_MCU_col[ci] =
-      (JDIMENSION)(long)(*xoffset * hsf) / (long)align;
+      (JDIMENSION) (long) (*xoffset * hsf) / (long) align;
    cinfo->master->last_MCU_col[ci] =
-      (JDIMENSION)jdiv_round_up((long)((*xoffset + cinfo->output_width) * hsf),
-                                (long)align) - 1;
+      (JDIMENSION) jdiv_round_up((long) ((*xoffset + cinfo->output_width) *
+                                         hsf),
+                                 (long) align) - 1;
  }

  if (reinit_upsampler) {
@@ -263,8 +263,8 @@ jpeg_crop_scanline(j_decompress_ptr cinfo, JDIMENSION *xoffset,
 */

 GLOBAL(JDIMENSION)
-jpeg_read_scanlines(j_decompress_ptr cinfo, JSAMPARRAY scanlines,
-                    JDIMENSION max_lines)
+jpeg_read_scanlines (j_decompress_ptr cinfo, JSAMPARRAY scanlines,
+                     JDIMENSION max_lines)
 {
  JDIMENSION row_ctr;

@@ -277,9 +277,9 @@ jpeg_read_scanlines(j_decompress_ptr cinfo, JSAMPARRAY scanlines,

  /* Call progress monitor hook if present */
  if (cinfo->progress != NULL) {
-    cinfo->progress->pass_counter = (long)cinfo->output_scanline;
-    cinfo->progress->pass_limit = (long)cinfo->output_height;
-    (*cinfo->progress->progress_monitor) ((j_common_ptr)cinfo);
+    cinfo->progress->pass_counter = (long) cinfo->output_scanline;
+    cinfo->progress->pass_limit = (long) cinfo->output_height;
+    (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
  }

  /* Process some data */
@@ -292,16 +292,16 @@ jpeg_read_scanlines(j_decompress_ptr cinfo, JSAMPARRAY scanlines,

 /* Dummy color convert function used by jpeg_skip_scanlines() */
 LOCAL(void)
-noop_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-             JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+noop_convert (j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+              JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
 {
 }


 /* Dummy quantize function used by jpeg_skip_scanlines() */
 LOCAL(void)
-noop_quantize(j_decompress_ptr cinfo, JSAMPARRAY input_buf,
-              JSAMPARRAY output_buf, int num_rows)
+noop_quantize (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
+               JSAMPARRAY output_buf, int num_rows)
 {
 }

@@ -315,44 +315,26 @@ noop_quantize(j_decompress_ptr cinfo, JSAMPARRAY input_buf,
 */

 LOCAL(void)
-read_and_discard_scanlines(j_decompress_ptr cinfo, JDIMENSION num_lines)
+read_and_discard_scanlines (j_decompress_ptr cinfo, JDIMENSION num_lines)
 {
  JDIMENSION n;
-  my_master_ptr master = (my_master_ptr)cinfo->master;
-  JSAMPLE dummy_sample[1] = { 0 };
-  JSAMPROW dummy_row = dummy_sample;
-  JSAMPARRAY scanlines = NULL;
  void (*color_convert) (j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
                         JDIMENSION input_row, JSAMPARRAY output_buf,
-                         int num_rows) = NULL;
+                         int num_rows);
  void (*color_quantize) (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
                          JSAMPARRAY output_buf, int num_rows) = NULL;

-  if (cinfo->cconvert && cinfo->cconvert->color_convert) {
-    color_convert = cinfo->cconvert->color_convert;
-    cinfo->cconvert->color_convert = noop_convert;
-    /* This just prevents UBSan from complaining about adding 0 to a NULL
-     * pointer.  The pointer isn't actually used.
-     */
-    scanlines = &dummy_row;
-  }
-
+  color_convert = cinfo->cconvert->color_convert;
+  cinfo->cconvert->color_convert = noop_convert;
  if (cinfo->cquantize && cinfo->cquantize->color_quantize) {
    color_quantize = cinfo->cquantize->color_quantize;
    cinfo->cquantize->color_quantize = noop_quantize;
  }

-  if (master->using_merged_upsample && cinfo->max_v_samp_factor == 2) {
-    my_merged_upsample_ptr upsample = (my_merged_upsample_ptr)cinfo->upsample;
-    scanlines = &upsample->spare_row;
-  }
-
  for (n = 0; n < num_lines; n++)
-    jpeg_read_scanlines(cinfo, scanlines, 1);
-
-  if (color_convert)
-    cinfo->cconvert->color_convert = color_convert;
+    jpeg_read_scanlines(cinfo, NULL, 1);

+  cinfo->cconvert->color_convert = color_convert;
  if (color_quantize)
    cinfo->cquantize->color_quantize = color_quantize;
 }
@@ -364,16 +346,10 @@ read_and_discard_scanlines(j_decompress_ptr cinfo, JDIMENSION num_lines)
 */

 LOCAL(void)
-increment_simple_rowgroup_ctr(j_decompress_ptr cinfo, JDIMENSION rows)
+increment_simple_rowgroup_ctr (j_decompress_ptr cinfo, JDIMENSION rows)
 {
  JDIMENSION rows_left;
-  my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
-  my_master_ptr master = (my_master_ptr)cinfo->master;
-
-  if (master->using_merged_upsample && cinfo->max_v_samp_factor == 2) {
-    read_and_discard_scanlines(cinfo, rows);
-    return;
-  }
+  my_main_ptr main_ptr = (my_main_ptr) cinfo->main;

  /* Increment the counter to the next row group after the skipped rows. */
  main_ptr->rowgroup_ctr += rows / cinfo->max_v_samp_factor;
@@ -399,31 +375,25 @@ increment_simple_rowgroup_ctr(j_decompress_ptr cinfo, JDIMENSION rows)
 */

 GLOBAL(JDIMENSION)
-jpeg_skip_scanlines(j_decompress_ptr cinfo, JDIMENSION num_lines)
+jpeg_skip_scanlines (j_decompress_ptr cinfo, JDIMENSION num_lines)
 {
-  my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
-  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
-  my_master_ptr master = (my_master_ptr)cinfo->master;
-  my_upsample_ptr upsample = (my_upsample_ptr)cinfo->upsample;
+  my_main_ptr main_ptr = (my_main_ptr) cinfo->main;
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
  JDIMENSION i, x;
  int y;
  JDIMENSION lines_per_iMCU_row, lines_left_in_iMCU_row, lines_after_iMCU_row;
  JDIMENSION lines_to_skip, lines_to_read;

-  /* Two-pass color quantization is not supported. */
-  if (cinfo->quantize_colors && cinfo->two_pass_quantize)
-    ERREXIT(cinfo, JERR_NOTIMPL);
-
  if (cinfo->global_state != DSTATE_SCANNING)
    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);

  /* Do not skip past the bottom of the image. */
  if (cinfo->output_scanline + num_lines >= cinfo->output_height) {
-    num_lines = cinfo->output_height - cinfo->output_scanline;
    cinfo->output_scanline = cinfo->output_height;
    (*cinfo->inputctl->finish_input_pass) (cinfo);
    cinfo->inputctl->eoi_reached = TRUE;
-    return num_lines;
+    return cinfo->output_height - cinfo->output_scanline;
  }

  if (num_lines == 0)
@@ -472,10 +442,8 @@ jpeg_skip_scanlines(j_decompress_ptr cinfo, JDIMENSION num_lines)
    main_ptr->buffer_full = FALSE;
    main_ptr->rowgroup_ctr = 0;
    main_ptr->context_state = CTX_PREPARE_FOR_IMCU;
-    if (!master->using_merged_upsample) {
-      upsample->next_row_out = cinfo->max_v_samp_factor;
-      upsample->rows_to_go = cinfo->output_height - cinfo->output_scanline;
-    }
+    upsample->next_row_out = cinfo->max_v_samp_factor;
+    upsample->rows_to_go = cinfo->output_height - cinfo->output_scanline;
  }

  /* Skipping is much simpler when context rows are not required. */
@@ -487,10 +455,8 @@ jpeg_skip_scanlines(j_decompress_ptr cinfo, JDIMENSION num_lines)
      cinfo->output_scanline += lines_left_in_iMCU_row;
      main_ptr->buffer_full = FALSE;
      main_ptr->rowgroup_ctr = 0;
-      if (!master->using_merged_upsample) {
-        upsample->next_row_out = cinfo->max_v_samp_factor;
-        upsample->rows_to_go = cinfo->output_height - cinfo->output_scanline;
-      }
+      upsample->next_row_out = cinfo->max_v_samp_factor;
+      upsample->rows_to_go = cinfo->output_height - cinfo->output_scanline;
    }
  }

@@ -515,7 +481,7 @@ jpeg_skip_scanlines(j_decompress_ptr cinfo, JDIMENSION num_lines)
    if (cinfo->upsample->need_context_rows) {
      cinfo->output_scanline += lines_to_skip;
      cinfo->output_iMCU_row += lines_to_skip / lines_per_iMCU_row;
-      main_ptr->iMCU_row_ctr += lines_to_skip / lines_per_iMCU_row;
+      main_ptr->iMCU_row_ctr += lines_after_iMCU_row / lines_per_iMCU_row;
      /* It is complex to properly move to the middle of a context block, so
       * read the remaining lines instead of skipping them.
       */
@@ -525,8 +491,7 @@ jpeg_skip_scanlines(j_decompress_ptr cinfo, JDIMENSION num_lines)
      cinfo->output_iMCU_row += lines_to_skip / lines_per_iMCU_row;
      increment_simple_rowgroup_ctr(cinfo, lines_to_read);
    }
-    if (!master->using_merged_upsample)
-      upsample->rows_to_go = cinfo->output_height - cinfo->output_scanline;
+    upsample->rows_to_go = cinfo->output_height - cinfo->output_scanline;
    return num_lines;
  }

@@ -538,8 +503,6 @@ jpeg_skip_scanlines(j_decompress_ptr cinfo, JDIMENSION num_lines)
         * decoded coefficients.  This is ~5% faster for large subsets, but
         * it's tough to tell a difference for smaller images.
         */
-        if (!cinfo->entropy->insufficient_data)
-          cinfo->master->last_good_iMCU_row = cinfo->input_iMCU_row;
        (*cinfo->entropy->decode_mcu) (cinfo, NULL);
      }
    }
@@ -569,8 +532,7 @@ jpeg_skip_scanlines(j_decompress_ptr cinfo, JDIMENSION num_lines)
   * bit odd, since "rows_to_go" seems to be redundantly keeping track of
   * output_scanline.
   */
-  if (!master->using_merged_upsample)
-    upsample->rows_to_go = cinfo->output_height - cinfo->output_scanline;
+  upsample->rows_to_go = cinfo->output_height - cinfo->output_scanline;

  /* Always skip the requested number of lines. */
  return num_lines;
@@ -582,8 +544,8 @@ jpeg_skip_scanlines(j_decompress_ptr cinfo, JDIMENSION num_lines)
 */

 GLOBAL(JDIMENSION)
-jpeg_read_raw_data(j_decompress_ptr cinfo, JSAMPIMAGE data,
-                   JDIMENSION max_lines)
+jpeg_read_raw_data (j_decompress_ptr cinfo, JSAMPIMAGE data,
+                    JDIMENSION max_lines)
 {
  JDIMENSION lines_per_iMCU_row;

@@ -596,9 +558,9 @@ jpeg_read_raw_data(j_decompress_ptr cinfo, JSAMPIMAGE data,

  /* Call progress monitor hook if present */
  if (cinfo->progress != NULL) {
-    cinfo->progress->pass_counter = (long)cinfo->output_scanline;
-    cinfo->progress->pass_limit = (long)cinfo->output_height;
-    (*cinfo->progress->progress_monitor) ((j_common_ptr)cinfo);
+    cinfo->progress->pass_counter = (long) cinfo->output_scanline;
+    cinfo->progress->pass_limit = (long) cinfo->output_height;
+    (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
  }

  /* Verify that at least one iMCU row can be returned. */
@@ -607,7 +569,7 @@ jpeg_read_raw_data(j_decompress_ptr cinfo, JSAMPIMAGE data,
    ERREXIT(cinfo, JERR_BUFFER_SIZE);

  /* Decompress directly into user's buffer. */
-  if (!(*cinfo->coef->decompress_data) (cinfo, data))
+  if (! (*cinfo->coef->decompress_data) (cinfo, data))
    return 0;                   /* suspension forced, can do nothing more */

  /* OK, we processed one iMCU row. */
@@ -625,7 +587,7 @@ jpeg_read_raw_data(j_decompress_ptr cinfo, JSAMPIMAGE data,
 */

 GLOBAL(boolean)
-jpeg_start_output(j_decompress_ptr cinfo, int scan_number)
+jpeg_start_output (j_decompress_ptr cinfo, int scan_number)
 {
  if (cinfo->global_state != DSTATE_BUFIMAGE &&
      cinfo->global_state != DSTATE_PRESCAN)
@@ -633,7 +595,8 @@ jpeg_start_output(j_decompress_ptr cinfo, int scan_number)
  /* Limit scan number to valid range */
  if (scan_number <= 0)
    scan_number = 1;
-  if (cinfo->inputctl->eoi_reached && scan_number > cinfo->input_scan_number)
+  if (cinfo->inputctl->eoi_reached &&
+      scan_number > cinfo->input_scan_number)
    scan_number = cinfo->input_scan_number;
  cinfo->output_scan_number = scan_number;
  /* Perform any dummy output passes, and set up for the real pass */
@@ -649,7 +612,7 @@ jpeg_start_output(j_decompress_ptr cinfo, int scan_number)
 */

 GLOBAL(boolean)
-jpeg_finish_output(j_decompress_ptr cinfo)
+jpeg_finish_output (j_decompress_ptr cinfo)
 {
  if ((cinfo->global_state == DSTATE_SCANNING ||
       cinfo->global_state == DSTATE_RAW_OK) && cinfo->buffered_image) {
@@ -663,7 +626,7 @@ jpeg_finish_output(j_decompress_ptr cinfo)
  }
  /* Read markers looking for SOS or EOI */
  while (cinfo->input_scan_number <= cinfo->output_scan_number &&
-         !cinfo->inputctl->eoi_reached) {
+         ! cinfo->inputctl->eoi_reached) {
    if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)
      return FALSE;             /* Suspend, come back later */
  }
@@ -4,19 +4,16 @@
 * This file was part of the Independent JPEG Group's software:
 * Developed 1997-2015 by Guido Vollbeding.
 * libjpeg-turbo Modifications:
- * Copyright (C) 2015-2020, D. R. Commander.
+ * Copyright (C) 2015-2016, D. R. Commander.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
 *
- * This file contains portable arithmetic entropy encoding routines for JPEG
- * (implementing Recommendation ITU-T T.81 | ISO/IEC 10918-1).
+ * This file contains portable arithmetic entropy decoding routines for JPEG
+ * (implementing the ISO/IEC IS 10918-1 and CCITT Recommendation ITU-T T.81).
 *
 * Both sequential and progressive modes are supported in this single module.
 *
 * Suspension is not currently supported in this module.
- *
- * NOTE: All referenced figures are from
- * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994.
 */

 #define JPEG_INTERNALS
@@ -24,7 +21,7 @@
 #include "jpeglib.h"


-#define NEG_1  ((unsigned int)-1)
+#define NEG_1 ((unsigned int)-1)


 /* Expanded entropy decoder object for arithmetic decoding. */
@@ -66,21 +63,21 @@ typedef arith_entropy_decoder *arith_entropy_ptr;
 * in the lower bits (mask 0x7F).
 */

-#define DC_STAT_BINS  64
-#define AC_STAT_BINS  256
+#define DC_STAT_BINS 64
+#define AC_STAT_BINS 256


 LOCAL(int)
-get_byte(j_decompress_ptr cinfo)
+get_byte (j_decompress_ptr cinfo)
 /* Read next input byte; we do not support suspension in this module. */
 {
  struct jpeg_source_mgr *src = cinfo->src;

  if (src->bytes_in_buffer == 0)
-    if (!(*src->fill_input_buffer) (cinfo))
+    if (! (*src->fill_input_buffer) (cinfo))
      ERREXIT(cinfo, JERR_CANT_SUSPEND);
  src->bytes_in_buffer--;
-  return *src->next_input_byte++;
+  return GETJOCTET(*src->next_input_byte++);
 }


@@ -112,9 +109,9 @@ get_byte(j_decompress_ptr cinfo)
 */

 LOCAL(int)
-arith_decode(j_decompress_ptr cinfo, unsigned char *st)
+arith_decode (j_decompress_ptr cinfo, unsigned char *st)
 {
-  register arith_entropy_ptr e = (arith_entropy_ptr)cinfo->entropy;
+  register arith_entropy_ptr e = (arith_entropy_ptr) cinfo->entropy;
  register unsigned char nl, nm;
  register JLONG qe, temp;
  register int sv, data;
@@ -159,8 +156,8 @@ arith_decode(j_decompress_ptr cinfo, unsigned char *st)
   */
  sv = *st;
  qe = jpeg_aritab[sv & 0x7F];  /* => Qe_Value */
-  nl = qe & 0xFF;  qe >>= 8;    /* Next_Index_LPS + Switch_MPS */
-  nm = qe & 0xFF;  qe >>= 8;    /* Next_Index_MPS */
+  nl = qe & 0xFF; qe >>= 8;     /* Next_Index_LPS + Switch_MPS */
+  nm = qe & 0xFF; qe >>= 8;     /* Next_Index_MPS */

  /* Decode & estimation procedures per sections D.2.4 & D.2.5 */
  temp = e->a - qe;
@@ -196,14 +193,14 @@ arith_decode(j_decompress_ptr cinfo, unsigned char *st)
 */

 LOCAL(void)
-process_restart(j_decompress_ptr cinfo)
+process_restart (j_decompress_ptr cinfo)
 {
-  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
  int ci;
  jpeg_component_info *compptr;

  /* Advance past the RSTn marker */
-  if (!(*cinfo->marker->read_restart_marker) (cinfo))
+  if (! (*cinfo->marker->read_restart_marker) (cinfo))
    ERREXIT(cinfo, JERR_CANT_SUSPEND);

  /* Re-initialize statistics areas */
@@ -247,9 +244,9 @@ process_restart(j_decompress_ptr cinfo)
 */

 METHODDEF(boolean)
-decode_mcu_DC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 {
-  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
  JBLOCKROW block;
  unsigned char *st;
  int blkn, ci, tbl, sign;
@@ -283,7 +280,7 @@ decode_mcu_DC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
      /* Figure F.21: Decoding nonzero value v */
      /* Figure F.22: Decoding the sign of v */
      sign = arith_decode(cinfo, st + 1);
-      st += 2;  st += sign;
+      st += 2; st += sign;
      /* Figure F.23: Decoding the magnitude category of v */
      if ((m = arith_decode(cinfo, st)) != 0) {
        st = entropy->dc_stats[tbl] + 20;       /* Table F.4: X1 = 20 */
@@ -297,9 +294,9 @@ decode_mcu_DC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
        }
      }
      /* Section F.1.4.4.1.2: Establish dc_context conditioning category */
-      if (m < (int)((1L << cinfo->arith_dc_L[tbl]) >> 1))
+      if (m < (int) ((1L << cinfo->arith_dc_L[tbl]) >> 1))
        entropy->dc_context[ci] = 0;               /* zero diff category */
-      else if (m > (int)((1L << cinfo->arith_dc_U[tbl]) >> 1))
+      else if (m > (int) ((1L << cinfo->arith_dc_U[tbl]) >> 1))
        entropy->dc_context[ci] = 12 + (sign * 4); /* large diff category */
      else
        entropy->dc_context[ci] = 4 + (sign * 4);  /* small diff category */
@@ -308,12 +305,12 @@ decode_mcu_DC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
      st += 14;
      while (m >>= 1)
        if (arith_decode(cinfo, st)) v |= m;
-      v += 1;  if (sign) v = -v;
-      entropy->last_dc_val[ci] = (entropy->last_dc_val[ci] + v) & 0xffff;
+      v += 1; if (sign) v = -v;
+      entropy->last_dc_val[ci] += v;
    }

    /* Scale and output the DC coefficient (assumes jpeg_natural_order[0]=0) */
-    (*block)[0] = (JCOEF)LEFT_SHIFT(entropy->last_dc_val[ci], cinfo->Al);
+    (*block)[0] = (JCOEF) LEFT_SHIFT(entropy->last_dc_val[ci], cinfo->Al);
  }

  return TRUE;
@@ -326,9 +323,9 @@ decode_mcu_DC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 */

 METHODDEF(boolean)
-decode_mcu_AC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 {
-  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
  JBLOCKROW block;
  unsigned char *st;
  int tbl, sign, k;
@@ -354,7 +351,7 @@ decode_mcu_AC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
    st = entropy->ac_stats[tbl] + 3 * (k - 1);
    if (arith_decode(cinfo, st)) break;         /* EOB flag */
    while (arith_decode(cinfo, st + 1) == 0) {
-      st += 3;  k++;
+      st += 3; k++;
      if (k > cinfo->Se) {
        WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
        entropy->ct = -1;                       /* spectral overflow */
@@ -386,9 +383,9 @@ decode_mcu_AC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
    st += 14;
    while (m >>= 1)
      if (arith_decode(cinfo, st)) v |= m;
-    v += 1;  if (sign) v = -v;
+    v += 1; if (sign) v = -v;
    /* Scale and output coefficient in natural (dezigzagged) order */
-    (*block)[jpeg_natural_order[k]] = (JCOEF)((unsigned)v << cinfo->Al);
+    (*block)[jpeg_natural_order[k]] = (JCOEF) ((unsigned)v << cinfo->Al);
  }

  return TRUE;
@@ -400,9 +397,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)
+decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 {
-  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
  unsigned char *st;
  int p1, blkn;

@@ -433,9 +430,9 @@ decode_mcu_DC_refine(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 */

 METHODDEF(boolean)
-decode_mcu_AC_refine(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 {
-  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
  JBLOCKROW block;
  JCOEFPTR thiscoef;
  unsigned char *st;
@@ -484,7 +481,7 @@ decode_mcu_AC_refine(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
          *thiscoef = p1;
        break;
      }
-      st += 3;  k++;
+      st += 3; k++;
      if (k > cinfo->Se) {
        WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
        entropy->ct = -1;                       /* spectral overflow */
@@ -502,9 +499,9 @@ decode_mcu_AC_refine(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 */

 METHODDEF(boolean)
-decode_mcu(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+decode_mcu (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 {
-  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
  jpeg_component_info *compptr;
  JBLOCKROW block;
  unsigned char *st;
@@ -541,7 +538,7 @@ decode_mcu(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
      /* Figure F.21: Decoding nonzero value v */
      /* Figure F.22: Decoding the sign of v */
      sign = arith_decode(cinfo, st + 1);
-      st += 2;  st += sign;
+      st += 2; st += sign;
      /* Figure F.23: Decoding the magnitude category of v */
      if ((m = arith_decode(cinfo, st)) != 0) {
        st = entropy->dc_stats[tbl] + 20;       /* Table F.4: X1 = 20 */
@@ -555,9 +552,9 @@ decode_mcu(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
        }
      }
      /* Section F.1.4.4.1.2: Establish dc_context conditioning category */
-      if (m < (int)((1L << cinfo->arith_dc_L[tbl]) >> 1))
+      if (m < (int) ((1L << cinfo->arith_dc_L[tbl]) >> 1))
        entropy->dc_context[ci] = 0;               /* zero diff category */
-      else if (m > (int)((1L << cinfo->arith_dc_U[tbl]) >> 1))
+      else if (m > (int) ((1L << cinfo->arith_dc_U[tbl]) >> 1))
        entropy->dc_context[ci] = 12 + (sign * 4); /* large diff category */
      else
        entropy->dc_context[ci] = 4 + (sign * 4);  /* small diff category */
@@ -566,12 +563,12 @@ decode_mcu(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
      st += 14;
      while (m >>= 1)
        if (arith_decode(cinfo, st)) v |= m;
-      v += 1;  if (sign) v = -v;
-      entropy->last_dc_val[ci] = (entropy->last_dc_val[ci] + v) & 0xffff;
+      v += 1; if (sign) v = -v;
+      entropy->last_dc_val[ci] += v;
    }

    if (block)
-      (*block)[0] = (JCOEF)entropy->last_dc_val[ci];
+      (*block)[0] = (JCOEF) entropy->last_dc_val[ci];

    /* Sections F.2.4.2 & F.1.4.4.2: Decoding of AC coefficients */

@@ -582,7 +579,7 @@ decode_mcu(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
      st = entropy->ac_stats[tbl] + 3 * (k - 1);
      if (arith_decode(cinfo, st)) break;       /* EOB flag */
      while (arith_decode(cinfo, st + 1) == 0) {
-        st += 3;  k++;
+        st += 3; k++;
        if (k > DCTSIZE2 - 1) {
          WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
          entropy->ct = -1;                     /* spectral overflow */
@@ -614,9 +611,9 @@ decode_mcu(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
      st += 14;
      while (m >>= 1)
        if (arith_decode(cinfo, st)) v |= m;
-      v += 1;  if (sign) v = -v;
+      v += 1; if (sign) v = -v;
      if (block)
-        (*block)[jpeg_natural_order[k]] = (JCOEF)v;
+        (*block)[jpeg_natural_order[k]] = (JCOEF) v;
    }
  }

@@ -629,9 +626,9 @@ decode_mcu(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 */

 METHODDEF(void)
-start_pass(j_decompress_ptr cinfo)
+start_pass (j_decompress_ptr cinfo)
 {
-  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
  int ci, tbl;
  jpeg_component_info *compptr;

@@ -650,11 +647,11 @@ start_pass(j_decompress_ptr cinfo)
    }
    if (cinfo->Ah != 0) {
      /* Successive approximation refinement scan: must have Al = Ah-1. */
-      if (cinfo->Ah - 1 != cinfo->Al)
+      if (cinfo->Ah-1 != cinfo->Al)
        goto bad;
    }
    if (cinfo->Al > 13) {       /* need not check for < 0 */
-bad:
+      bad:
      ERREXIT4(cinfo, JERR_BAD_PROGRESSION,
               cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al);
    }
@@ -664,17 +661,9 @@ bad:
     */
    for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
      int coefi, cindex = cinfo->cur_comp_info[ci]->component_index;
-      int *coef_bit_ptr = &cinfo->coef_bits[cindex][0];
-      int *prev_coef_bit_ptr =
-        &cinfo->coef_bits[cindex + cinfo->num_components][0];
+      int *coef_bit_ptr = & cinfo->coef_bits[cindex][0];
      if (cinfo->Ss && coef_bit_ptr[0] < 0) /* AC without prior DC scan */
        WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, 0);
-      for (coefi = MIN(cinfo->Ss, 1); coefi <= MAX(cinfo->Se, 9); coefi++) {
-        if (cinfo->input_scan_number > 1)
-          prev_coef_bit_ptr[coefi] = coef_bit_ptr[coefi];
-        else
-          prev_coef_bit_ptr[coefi] = 0;
-      }
      for (coefi = cinfo->Ss; coefi <= cinfo->Se; coefi++) {
        int expected = (coef_bit_ptr[coefi] < 0) ? 0 : coef_bit_ptr[coefi];
        if (cinfo->Ah != expected)
@@ -713,8 +702,8 @@ bad:
      if (tbl < 0 || tbl >= NUM_ARITH_TBLS)
        ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl);
      if (entropy->dc_stats[tbl] == NULL)
-        entropy->dc_stats[tbl] = (unsigned char *)(*cinfo->mem->alloc_small)
-          ((j_common_ptr)cinfo, JPOOL_IMAGE, DC_STAT_BINS);
+        entropy->dc_stats[tbl] = (unsigned char *) (*cinfo->mem->alloc_small)
+          ((j_common_ptr) cinfo, JPOOL_IMAGE, DC_STAT_BINS);
      MEMZERO(entropy->dc_stats[tbl], DC_STAT_BINS);
      /* Initialize DC predictions to 0 */
      entropy->last_dc_val[ci] = 0;
@@ -725,8 +714,8 @@ bad:
      if (tbl < 0 || tbl >= NUM_ARITH_TBLS)
        ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl);
      if (entropy->ac_stats[tbl] == NULL)
-        entropy->ac_stats[tbl] = (unsigned char *)(*cinfo->mem->alloc_small)
-          ((j_common_ptr)cinfo, JPOOL_IMAGE, AC_STAT_BINS);
+        entropy->ac_stats[tbl] = (unsigned char *) (*cinfo->mem->alloc_small)
+          ((j_common_ptr) cinfo, JPOOL_IMAGE, AC_STAT_BINS);
      MEMZERO(entropy->ac_stats[tbl], AC_STAT_BINS);
    }
  }
@@ -735,7 +724,6 @@ bad:
  entropy->c = 0;
  entropy->a = 0;
  entropy->ct = -16;    /* force reading 2 initial bytes to fill C */
-  entropy->pub.insufficient_data = FALSE;

  /* Initialize restart counter */
  entropy->restarts_to_go = cinfo->restart_interval;
@@ -747,15 +735,15 @@ bad:
 */

 GLOBAL(void)
-jinit_arith_decoder(j_decompress_ptr cinfo)
+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,
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                sizeof(arith_entropy_decoder));
-  cinfo->entropy = (struct jpeg_entropy_decoder *)entropy;
+  cinfo->entropy = (struct jpeg_entropy_decoder *) entropy;
  entropy->pub.start_pass = start_pass;

  /* Mark tables unallocated */
@@ -771,10 +759,9 @@ jinit_arith_decoder(j_decompress_ptr cinfo)
    /* 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 * 2 * DCTSIZE2 *
-                                  sizeof(int));
-    coef_bit_ptr = &cinfo->coef_bits[0][0];
+      (*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++)
        *coef_bit_ptr++ = -1;
@@ -24,8 +24,8 @@
 #include "jerror.h"

 #ifndef HAVE_STDLIB_H           /* <stdlib.h> should declare malloc(),free() */
-extern void *malloc(size_t size);
-extern void free(void *ptr);
+extern void *malloc (size_t size);
+extern void free (void *ptr);
 #endif


@@ -66,14 +66,14 @@ typedef my_mem_destination_mgr *my_mem_dest_ptr;
 */

 METHODDEF(void)
-init_destination(j_compress_ptr cinfo)
+init_destination (j_compress_ptr cinfo)
 {
-  my_dest_ptr dest = (my_dest_ptr)cinfo->dest;
+  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));
+      (*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;
@@ -81,7 +81,7 @@ init_destination(j_compress_ptr cinfo)

 #if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
 METHODDEF(void)
-init_mem_destination(j_compress_ptr cinfo)
+init_mem_destination (j_compress_ptr cinfo)
 {
  /* no work necessary here */
 }
@@ -112,12 +112,12 @@ init_mem_destination(j_compress_ptr cinfo)
 */

 METHODDEF(boolean)
-empty_output_buffer(j_compress_ptr cinfo)
+empty_output_buffer (j_compress_ptr cinfo)
 {
-  my_dest_ptr dest = (my_dest_ptr)cinfo->dest;
+  my_dest_ptr dest = (my_dest_ptr) cinfo->dest;

  if (JFWRITE(dest->outfile, dest->buffer, OUTPUT_BUF_SIZE) !=
-      (size_t)OUTPUT_BUF_SIZE)
+      (size_t) OUTPUT_BUF_SIZE)
    ERREXIT(cinfo, JERR_FILE_WRITE);

  dest->pub.next_output_byte = dest->buffer;
@@ -128,22 +128,23 @@ empty_output_buffer(j_compress_ptr cinfo)

 #if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
 METHODDEF(boolean)
-empty_mem_output_buffer(j_compress_ptr cinfo)
+empty_mem_output_buffer (j_compress_ptr cinfo)
 {
  size_t nextsize;
  JOCTET *nextbuffer;
-  my_mem_dest_ptr dest = (my_mem_dest_ptr)cinfo->dest;
+  my_mem_dest_ptr dest = (my_mem_dest_ptr) cinfo->dest;

  /* Try to allocate new buffer with double size */
  nextsize = dest->bufsize * 2;
-  nextbuffer = (JOCTET *)malloc(nextsize);
+  nextbuffer = (JOCTET *) malloc(nextsize);

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

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

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

  dest->newbuffer = nextbuffer;

@@ -168,9 +169,9 @@ empty_mem_output_buffer(j_compress_ptr cinfo)
 */

 METHODDEF(void)
-term_destination(j_compress_ptr cinfo)
+term_destination (j_compress_ptr cinfo)
 {
-  my_dest_ptr dest = (my_dest_ptr)cinfo->dest;
+  my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
  size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer;

  /* Write any data remaining in the buffer */
@@ -186,9 +187,9 @@ term_destination(j_compress_ptr cinfo)

 #if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
 METHODDEF(void)
-term_mem_destination(j_compress_ptr cinfo)
+term_mem_destination (j_compress_ptr cinfo)
 {
-  my_mem_dest_ptr dest = (my_mem_dest_ptr)cinfo->dest;
+  my_mem_dest_ptr dest = (my_mem_dest_ptr) cinfo->dest;

  *dest->outbuffer = dest->buffer;
  *dest->outsize = (unsigned long)(dest->bufsize - dest->pub.free_in_buffer);
@@ -203,7 +204,7 @@ term_mem_destination(j_compress_ptr cinfo)
 */

 GLOBAL(void)
-jpeg_stdio_dest(j_compress_ptr cinfo, FILE *outfile)
+jpeg_stdio_dest (j_compress_ptr cinfo, FILE *outfile)
 {
  my_dest_ptr dest;

@@ -212,7 +213,7 @@ jpeg_stdio_dest(j_compress_ptr cinfo, FILE *outfile)
   */
  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,
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
                                  sizeof(my_destination_mgr));
  } else if (cinfo->dest->init_destination != init_destination) {
    /* It is unsafe to reuse the existing destination manager unless it was
@@ -224,7 +225,7 @@ jpeg_stdio_dest(j_compress_ptr cinfo, FILE *outfile)
    ERREXIT(cinfo, JERR_BUFFER_SIZE);
  }

-  dest = (my_dest_ptr)cinfo->dest;
+  dest = (my_dest_ptr) cinfo->dest;
  dest->pub.init_destination = init_destination;
  dest->pub.empty_output_buffer = empty_output_buffer;
  dest->pub.term_destination = term_destination;
@@ -248,8 +249,8 @@ jpeg_stdio_dest(j_compress_ptr cinfo, FILE *outfile)
 */

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

@@ -261,7 +262,7 @@ jpeg_mem_dest(j_compress_ptr cinfo, unsigned char **outbuffer,
   */
  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,
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
                                  sizeof(my_mem_destination_mgr));
  } else if (cinfo->dest->init_destination != init_mem_destination) {
    /* It is unsafe to reuse the existing destination manager unless it was
@@ -270,7 +271,7 @@ jpeg_mem_dest(j_compress_ptr cinfo, unsigned char **outbuffer,
    ERREXIT(cinfo, JERR_BUFFER_SIZE);
  }

-  dest = (my_mem_dest_ptr)cinfo->dest;
+  dest = (my_mem_dest_ptr) cinfo->dest;
  dest->pub.init_destination = init_mem_destination;
  dest->pub.empty_output_buffer = empty_mem_output_buffer;
  dest->pub.term_destination = term_mem_destination;
@@ -280,7 +281,7 @@ jpeg_mem_dest(j_compress_ptr cinfo, unsigned char **outbuffer,

  if (*outbuffer == NULL || *outsize == 0) {
    /* Allocate initial buffer */
-    dest->newbuffer = *outbuffer = (unsigned char *)malloc(OUTPUT_BUF_SIZE);
+    dest->newbuffer = *outbuffer = (unsigned char *) malloc(OUTPUT_BUF_SIZE);
    if (dest->newbuffer == NULL)
      ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 10);
    *outsize = OUTPUT_BUF_SIZE;
@@ -45,9 +45,9 @@ typedef my_source_mgr *my_src_ptr;
 */

 METHODDEF(void)
-init_source(j_decompress_ptr cinfo)
+init_source (j_decompress_ptr cinfo)
 {
-  my_src_ptr src = (my_src_ptr)cinfo->src;
+  my_src_ptr src = (my_src_ptr) cinfo->src;

  /* We reset the empty-input-file flag for each image,
   * but we don't clear the input buffer.
@@ -58,7 +58,7 @@ init_source(j_decompress_ptr cinfo)

 #if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
 METHODDEF(void)
-init_mem_source(j_decompress_ptr cinfo)
+init_mem_source (j_decompress_ptr cinfo)
 {
  /* no work necessary here */
 }
@@ -99,9 +99,9 @@ init_mem_source(j_decompress_ptr cinfo)
 */

 METHODDEF(boolean)
-fill_input_buffer(j_decompress_ptr cinfo)
+fill_input_buffer (j_decompress_ptr cinfo)
 {
-  my_src_ptr src = (my_src_ptr)cinfo->src;
+  my_src_ptr src = (my_src_ptr) cinfo->src;
  size_t nbytes;

  nbytes = JFREAD(src->infile, src->buffer, INPUT_BUF_SIZE);
@@ -111,8 +111,8 @@ fill_input_buffer(j_decompress_ptr cinfo)
      ERREXIT(cinfo, JERR_INPUT_EMPTY);
    WARNMS(cinfo, JWRN_JPEG_EOF);
    /* Insert a fake EOI marker */
-    src->buffer[0] = (JOCTET)0xFF;
-    src->buffer[1] = (JOCTET)JPEG_EOI;
+    src->buffer[0] = (JOCTET) 0xFF;
+    src->buffer[1] = (JOCTET) JPEG_EOI;
    nbytes = 2;
  }

@@ -125,10 +125,10 @@ fill_input_buffer(j_decompress_ptr cinfo)

 #if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
 METHODDEF(boolean)
-fill_mem_input_buffer(j_decompress_ptr cinfo)
+fill_mem_input_buffer (j_decompress_ptr cinfo)
 {
  static const JOCTET mybuffer[4] = {
-    (JOCTET)0xFF, (JOCTET)JPEG_EOI, 0, 0
+    (JOCTET) 0xFF, (JOCTET) JPEG_EOI, 0, 0
  };

  /* The whole JPEG data is expected to reside in the supplied memory
@@ -160,7 +160,7 @@ fill_mem_input_buffer(j_decompress_ptr cinfo)
 */

 METHODDEF(void)
-skip_input_data(j_decompress_ptr cinfo, long num_bytes)
+skip_input_data (j_decompress_ptr cinfo, long num_bytes)
 {
  struct jpeg_source_mgr *src = cinfo->src;

@@ -169,15 +169,15 @@ skip_input_data(j_decompress_ptr cinfo, long num_bytes)
   * any trouble anyway --- large skips are infrequent.
   */
  if (num_bytes > 0) {
-    while (num_bytes > (long)src->bytes_in_buffer) {
-      num_bytes -= (long)src->bytes_in_buffer;
-      (void)(*src->fill_input_buffer) (cinfo);
+    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 += (size_t)num_bytes;
-    src->bytes_in_buffer -= (size_t)num_bytes;
+    src->next_input_byte += (size_t) num_bytes;
+    src->bytes_in_buffer -= (size_t) num_bytes;
  }
 }

@@ -201,7 +201,7 @@ skip_input_data(j_decompress_ptr cinfo, long num_bytes)
 */

 METHODDEF(void)
-term_source(j_decompress_ptr cinfo)
+term_source (j_decompress_ptr cinfo)
 {
  /* no work necessary here */
 }
@@ -214,7 +214,7 @@ term_source(j_decompress_ptr cinfo)
 */

 GLOBAL(void)
-jpeg_stdio_src(j_decompress_ptr cinfo, FILE *infile)
+jpeg_stdio_src (j_decompress_ptr cinfo, FILE *infile)
 {
  my_src_ptr src;

@@ -225,11 +225,11 @@ jpeg_stdio_src(j_decompress_ptr cinfo, FILE *infile)
   */
  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,
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
                                  sizeof(my_source_mgr));
-    src = (my_src_ptr)cinfo->src;
+    src = (my_src_ptr) cinfo->src;
    src->buffer = (JOCTET *)
-      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
                                  INPUT_BUF_SIZE * sizeof(JOCTET));
  } else if (cinfo->src->init_source != init_source) {
    /* It is unsafe to reuse the existing source manager unless it was created
@@ -241,7 +241,7 @@ jpeg_stdio_src(j_decompress_ptr cinfo, FILE *infile)
    ERREXIT(cinfo, JERR_BUFFER_SIZE);
  }

-  src = (my_src_ptr)cinfo->src;
+  src = (my_src_ptr) cinfo->src;
  src->pub.init_source = init_source;
  src->pub.fill_input_buffer = fill_input_buffer;
  src->pub.skip_input_data = skip_input_data;
@@ -260,8 +260,8 @@ jpeg_stdio_src(j_decompress_ptr cinfo, FILE *infile)
 */

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

@@ -274,7 +274,7 @@ jpeg_mem_src(j_decompress_ptr cinfo, const unsigned char *inbuffer,
   */
  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,
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
                                  sizeof(struct jpeg_source_mgr));
  } else if (cinfo->src->init_source != init_mem_source) {
    /* It is unsafe to reuse the existing source manager unless it was created
@@ -289,7 +289,7 @@ jpeg_mem_src(j_decompress_ptr cinfo, const unsigned char *inbuffer,
  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 = (size_t)insize;
-  src->next_input_byte = (const JOCTET *)inbuffer;
+  src->bytes_in_buffer = (size_t) insize;
+  src->next_input_byte = (const JOCTET *) inbuffer;
 }
 #endif
@@ -5,8 +5,8 @@
 * Copyright (C) 1994-1997, Thomas G. Lane.
 * libjpeg-turbo Modifications:
 * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
- * Copyright (C) 2010, 2015-2016, 2019-2020, D. R. Commander.
- * Copyright (C) 2015, 2020, Google, Inc.
+ * Copyright (C) 2010, 2015-2016, D. R. Commander.
+ * Copyright (C) 2015, Google, Inc.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
 *
@@ -25,15 +25,16 @@


 /* Forward declarations */
-METHODDEF(int) decompress_onepass(j_decompress_ptr cinfo,
-                                  JSAMPIMAGE output_buf);
+METHODDEF(int) decompress_onepass
+        (j_decompress_ptr cinfo, JSAMPIMAGE output_buf);
 #ifdef D_MULTISCAN_FILES_SUPPORTED
-METHODDEF(int) decompress_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf);
+METHODDEF(int) decompress_data
+        (j_decompress_ptr cinfo, JSAMPIMAGE output_buf);
 #endif
 #ifdef BLOCK_SMOOTHING_SUPPORTED
-LOCAL(boolean) smoothing_ok(j_decompress_ptr cinfo);
-METHODDEF(int) decompress_smooth_data(j_decompress_ptr cinfo,
-                                      JSAMPIMAGE output_buf);
+LOCAL(boolean) smoothing_ok (j_decompress_ptr cinfo);
+METHODDEF(int) decompress_smooth_data
+        (j_decompress_ptr cinfo, JSAMPIMAGE output_buf);
 #endif


@@ -42,7 +43,7 @@ METHODDEF(int) decompress_smooth_data(j_decompress_ptr cinfo,
 */

 METHODDEF(void)
-start_input_pass(j_decompress_ptr cinfo)
+start_input_pass (j_decompress_ptr cinfo)
 {
  cinfo->input_iMCU_row = 0;
  start_iMCU_row(cinfo);
@@ -54,10 +55,10 @@ start_input_pass(j_decompress_ptr cinfo)
 */

 METHODDEF(void)
-start_output_pass(j_decompress_ptr cinfo)
+start_output_pass (j_decompress_ptr cinfo)
 {
 #ifdef BLOCK_SMOOTHING_SUPPORTED
-  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;

  /* If multipass, check to see whether to use block smoothing on this pass */
  if (coef->pub.coef_arrays != NULL) {
@@ -82,9 +83,9 @@ start_output_pass(j_decompress_ptr cinfo)
 */

 METHODDEF(int)
-decompress_onepass(j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
+decompress_onepass (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
 {
-  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
  JDIMENSION MCU_col_num;       /* index of current MCU within row */
  JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
@@ -100,11 +101,9 @@ decompress_onepass(j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
    for (MCU_col_num = coef->MCU_ctr; MCU_col_num <= last_MCU_col;
         MCU_col_num++) {
      /* Try to fetch an MCU.  Entropy decoder expects buffer to be zeroed. */
-      jzero_far((void *)coef->MCU_buffer[0],
-                (size_t)(cinfo->blocks_in_MCU * sizeof(JBLOCK)));
-      if (!cinfo->entropy->insufficient_data)
-        cinfo->master->last_good_iMCU_row = cinfo->input_iMCU_row;
-      if (!(*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
+      jzero_far((void *) coef->MCU_buffer[0],
+                (size_t) (cinfo->blocks_in_MCU * sizeof(JBLOCK)));
+      if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
        /* Suspension forced; update state counters and exit */
        coef->MCU_vert_offset = yoffset;
        coef->MCU_ctr = MCU_col_num;
@@ -121,28 +120,28 @@ decompress_onepass(j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
         * incremented past them!).  Note the inner loop relies on having
         * allocated the MCU_buffer[] blocks sequentially.
         */
-        blkn = 0;               /* index of current DCT block within MCU */
+        blkn = 0;                 /* index of current DCT block within MCU */
        for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
          compptr = cinfo->cur_comp_info[ci];
          /* Don't bother to IDCT an uninteresting component. */
-          if (!compptr->component_needed) {
+          if (! compptr->component_needed) {
            blkn += compptr->MCU_blocks;
            continue;
          }
          inverse_DCT = cinfo->idct->inverse_DCT[compptr->component_index];
-          useful_width = (MCU_col_num < last_MCU_col) ?
-                         compptr->MCU_width : compptr->last_col_width;
+          useful_width = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
+                                                      : compptr->last_col_width;
          output_ptr = output_buf[compptr->component_index] +
-                       yoffset * compptr->_DCT_scaled_size;
+            yoffset * compptr->_DCT_scaled_size;
          start_col = (MCU_col_num - cinfo->master->first_iMCU_col) *
-                      compptr->MCU_sample_width;
+              compptr->MCU_sample_width;
          for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
            if (cinfo->input_iMCU_row < last_iMCU_row ||
-                yoffset + yindex < compptr->last_row_height) {
+                yoffset+yindex < compptr->last_row_height) {
              output_col = start_col;
              for (xindex = 0; xindex < useful_width; xindex++) {
                (*inverse_DCT) (cinfo, compptr,
-                                (JCOEFPTR)coef->MCU_buffer[blkn + xindex],
+                                (JCOEFPTR) coef->MCU_buffer[blkn+xindex],
                                output_ptr, output_col);
                output_col += compptr->_DCT_scaled_size;
              }
@@ -173,7 +172,7 @@ decompress_onepass(j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
 */

 METHODDEF(int)
-dummy_consume_data(j_decompress_ptr cinfo)
+dummy_consume_data (j_decompress_ptr cinfo)
 {
  return JPEG_SUSPENDED;        /* Always indicate nothing was done */
 }
@@ -189,9 +188,9 @@ dummy_consume_data(j_decompress_ptr cinfo)
 */

 METHODDEF(int)
-consume_data(j_decompress_ptr cinfo)
+consume_data (j_decompress_ptr cinfo)
 {
-  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
  JDIMENSION MCU_col_num;       /* index of current MCU within row */
  int blkn, ci, xindex, yindex, yoffset;
  JDIMENSION start_col;
@@ -203,9 +202,9 @@ consume_data(j_decompress_ptr cinfo)
  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
    compptr = cinfo->cur_comp_info[ci];
    buffer[ci] = (*cinfo->mem->access_virt_barray)
-      ((j_common_ptr)cinfo, coef->whole_image[compptr->component_index],
+      ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index],
       cinfo->input_iMCU_row * compptr->v_samp_factor,
-       (JDIMENSION)compptr->v_samp_factor, TRUE);
+       (JDIMENSION) compptr->v_samp_factor, TRUE);
    /* Note: entropy decoder expects buffer to be zeroed,
     * but this is handled automatically by the memory manager
     * because we requested a pre-zeroed array.
@@ -223,16 +222,14 @@ consume_data(j_decompress_ptr cinfo)
        compptr = cinfo->cur_comp_info[ci];
        start_col = MCU_col_num * compptr->MCU_width;
        for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
-          buffer_ptr = buffer[ci][yindex + yoffset] + start_col;
+          buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
          for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
            coef->MCU_buffer[blkn++] = buffer_ptr++;
          }
        }
      }
-      if (!cinfo->entropy->insufficient_data)
-        cinfo->master->last_good_iMCU_row = cinfo->input_iMCU_row;
      /* Try to fetch the MCU. */
-      if (!(*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
+      if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
        /* Suspension forced; update state counters and exit */
        coef->MCU_vert_offset = yoffset;
        coef->MCU_ctr = MCU_col_num;
@@ -262,9 +259,9 @@ consume_data(j_decompress_ptr cinfo)
 */

 METHODDEF(int)
-decompress_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
+decompress_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
 {
-  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
  JDIMENSION block_num;
  int ci, block_row, block_rows;
@@ -279,7 +276,7 @@ decompress_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
  while (cinfo->input_scan_number < cinfo->output_scan_number ||
         (cinfo->input_scan_number == cinfo->output_scan_number &&
          cinfo->input_iMCU_row <= cinfo->output_iMCU_row)) {
-    if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)
+    if ((*cinfo->inputctl->consume_input)(cinfo) == JPEG_SUSPENDED)
      return JPEG_SUSPENDED;
  }

@@ -287,19 +284,19 @@ decompress_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
       ci++, compptr++) {
    /* Don't bother to IDCT an uninteresting component. */
-    if (!compptr->component_needed)
+    if (! compptr->component_needed)
      continue;
    /* Align the virtual buffer for this component. */
    buffer = (*cinfo->mem->access_virt_barray)
-      ((j_common_ptr)cinfo, coef->whole_image[ci],
+      ((j_common_ptr) cinfo, coef->whole_image[ci],
       cinfo->output_iMCU_row * compptr->v_samp_factor,
-       (JDIMENSION)compptr->v_samp_factor, FALSE);
+       (JDIMENSION) compptr->v_samp_factor, FALSE);
    /* Count non-dummy DCT block rows in this iMCU row. */
    if (cinfo->output_iMCU_row < last_iMCU_row)
      block_rows = compptr->v_samp_factor;
    else {
      /* NB: can't use last_row_height here; it is input-side-dependent! */
-      block_rows = (int)(compptr->height_in_blocks % compptr->v_samp_factor);
+      block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
      if (block_rows == 0) block_rows = compptr->v_samp_factor;
    }
    inverse_DCT = cinfo->idct->inverse_DCT[ci];
@@ -310,8 +307,8 @@ decompress_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
      output_col = 0;
      for (block_num = cinfo->master->first_MCU_col[ci];
           block_num <= cinfo->master->last_MCU_col[ci]; block_num++) {
-        (*inverse_DCT) (cinfo, compptr, (JCOEFPTR)buffer_ptr, output_ptr,
-                        output_col);
+        (*inverse_DCT) (cinfo, compptr, (JCOEFPTR) buffer_ptr,
+                        output_ptr, output_col);
        buffer_ptr++;
        output_col += compptr->_DCT_scaled_size;
      }
@@ -330,22 +327,19 @@ decompress_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
 #ifdef BLOCK_SMOOTHING_SUPPORTED

 /*
- * This code applies interblock smoothing; the first 9 AC coefficients are
- * estimated from the DC values of a DCT block and its 24 neighboring blocks.
+ * This code applies interblock smoothing as described by section K.8
+ * of the JPEG standard: the first 5 AC coefficients are estimated from
+ * the DC values of a DCT block and its 8 neighboring blocks.
 * We apply smoothing only for progressive JPEG decoding, and only if
 * the coefficients it can estimate are not yet known to full precision.
 */

-/* Natural-order array positions of the first 9 zigzag-order coefficients */
+/* Natural-order array positions of the first 5 zigzag-order coefficients */
 #define Q01_POS  1
 #define Q10_POS  8
 #define Q20_POS  16
 #define Q11_POS  9
 #define Q02_POS  2
-#define Q03_POS  3
-#define Q12_POS  10
-#define Q21_POS  17
-#define Q30_POS  24

 /*
 * Determine whether block smoothing is applicable and safe.
@@ -356,64 +350,51 @@ decompress_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
 */

 LOCAL(boolean)
-smoothing_ok(j_decompress_ptr cinfo)
+smoothing_ok (j_decompress_ptr cinfo)
 {
-  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
  boolean smoothing_useful = FALSE;
  int ci, coefi;
  jpeg_component_info *compptr;
  JQUANT_TBL *qtable;
-  int *coef_bits, *prev_coef_bits;
-  int *coef_bits_latch, *prev_coef_bits_latch;
+  int *coef_bits;
+  int *coef_bits_latch;

-  if (!cinfo->progressive_mode || cinfo->coef_bits == NULL)
+  if (! cinfo->progressive_mode || cinfo->coef_bits == NULL)
    return FALSE;

  /* Allocate latch area if not already done */
  if (coef->coef_bits_latch == NULL)
    coef->coef_bits_latch = (int *)
-      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                  cinfo->num_components * 2 *
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+                                  cinfo->num_components *
                                  (SAVED_COEFS * sizeof(int)));
  coef_bits_latch = coef->coef_bits_latch;
-  prev_coef_bits_latch =
-    &coef->coef_bits_latch[cinfo->num_components * SAVED_COEFS];

  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
       ci++, compptr++) {
    /* All components' quantization values must already be latched. */
    if ((qtable = compptr->quant_table) == NULL)
      return FALSE;
-    /* Verify DC & first 9 AC quantizers are nonzero to avoid zero-divide. */
+    /* Verify DC & first 5 AC quantizers are nonzero to avoid zero-divide. */
    if (qtable->quantval[0] == 0 ||
        qtable->quantval[Q01_POS] == 0 ||
        qtable->quantval[Q10_POS] == 0 ||
        qtable->quantval[Q20_POS] == 0 ||
        qtable->quantval[Q11_POS] == 0 ||
-        qtable->quantval[Q02_POS] == 0 ||
-        qtable->quantval[Q03_POS] == 0 ||
-        qtable->quantval[Q12_POS] == 0 ||
-        qtable->quantval[Q21_POS] == 0 ||
-        qtable->quantval[Q30_POS] == 0)
+        qtable->quantval[Q02_POS] == 0)
      return FALSE;
    /* DC values must be at least partly known for all components. */
    coef_bits = cinfo->coef_bits[ci];
-    prev_coef_bits = cinfo->coef_bits[ci + cinfo->num_components];
    if (coef_bits[0] < 0)
      return FALSE;
-    coef_bits_latch[0] = coef_bits[0];
    /* Block smoothing is helpful if some AC coefficients remain inaccurate. */
-    for (coefi = 1; coefi < SAVED_COEFS; coefi++) {
-      if (cinfo->input_scan_number > 1)
-        prev_coef_bits_latch[coefi] = prev_coef_bits[coefi];
-      else
-        prev_coef_bits_latch[coefi] = -1;
+    for (coefi = 1; coefi <= 5; coefi++) {
      coef_bits_latch[coefi] = coef_bits[coefi];
      if (coef_bits[coefi] != 0)
        smoothing_useful = TRUE;
    }
    coef_bits_latch += SAVED_COEFS;
-    prev_coef_bits_latch += SAVED_COEFS;
  }

  return smoothing_useful;
@@ -425,27 +406,24 @@ smoothing_ok(j_decompress_ptr cinfo)
 */

 METHODDEF(int)
-decompress_smooth_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
+decompress_smooth_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
 {
-  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
  JDIMENSION block_num, last_block_column;
  int ci, block_row, block_rows, access_rows;
  JBLOCKARRAY buffer;
-  JBLOCKROW buffer_ptr, prev_prev_block_row, prev_block_row;
-  JBLOCKROW next_block_row, next_next_block_row;
+  JBLOCKROW buffer_ptr, prev_block_row, next_block_row;
  JSAMPARRAY output_ptr;
  JDIMENSION output_col;
  jpeg_component_info *compptr;
  inverse_DCT_method_ptr inverse_DCT;
-  boolean change_dc;
+  boolean first_row, last_row;
  JCOEF *workspace;
  int *coef_bits;
  JQUANT_TBL *quanttbl;
-  JLONG Q00, Q01, Q02, Q03 = 0, Q10, Q11, Q12 = 0, Q20, Q21 = 0, Q30 = 0, num;
-  int DC01, DC02, DC03, DC04, DC05, DC06, DC07, DC08, DC09, DC10, DC11, DC12,
-      DC13, DC14, DC15, DC16, DC17, DC18, DC19, DC20, DC21, DC22, DC23, DC24,
-      DC25;
+  JLONG Q00,Q01,Q02,Q10,Q11,Q20, num;
+  int DC1,DC2,DC3,DC4,DC5,DC6,DC7,DC8,DC9;
  int Al, pred;

  /* Keep a local variable to avoid looking it up more than once */
@@ -453,18 +431,18 @@ decompress_smooth_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf)

  /* Force some input to be done if we are getting ahead of the input. */
  while (cinfo->input_scan_number <= cinfo->output_scan_number &&
-         !cinfo->inputctl->eoi_reached) {
+         ! cinfo->inputctl->eoi_reached) {
    if (cinfo->input_scan_number == cinfo->output_scan_number) {
      /* If input is working on current scan, we ordinarily want it to
       * have completed the current row.  But if input scan is DC,
-       * we want it to keep two rows ahead so that next two block rows' DC
+       * we want it to keep one row ahead so that next block row's DC
       * values are up to date.
       */
-      JDIMENSION delta = (cinfo->Ss == 0) ? 2 : 0;
-      if (cinfo->input_iMCU_row > cinfo->output_iMCU_row + delta)
+      JDIMENSION delta = (cinfo->Ss == 0) ? 1 : 0;
+      if (cinfo->input_iMCU_row > cinfo->output_iMCU_row+delta)
        break;
    }
-    if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)
+    if ((*cinfo->inputctl->consume_input)(cinfo) == JPEG_SUSPENDED)
      return JPEG_SUSPENDED;
  }

@@ -472,56 +450,37 @@ decompress_smooth_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
       ci++, compptr++) {
    /* Don't bother to IDCT an uninteresting component. */
-    if (!compptr->component_needed)
+    if (! compptr->component_needed)
      continue;
    /* Count non-dummy DCT block rows in this iMCU row. */
-    if (cinfo->output_iMCU_row < last_iMCU_row - 1) {
-      block_rows = compptr->v_samp_factor;
-      access_rows = block_rows * 3; /* this and next two iMCU rows */
-    } else if (cinfo->output_iMCU_row < last_iMCU_row) {
+    if (cinfo->output_iMCU_row < last_iMCU_row) {
      block_rows = compptr->v_samp_factor;
      access_rows = block_rows * 2; /* this and next iMCU row */
+      last_row = FALSE;
    } else {
      /* NB: can't use last_row_height here; it is input-side-dependent! */
-      block_rows = (int)(compptr->height_in_blocks % compptr->v_samp_factor);
+      block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
      if (block_rows == 0) block_rows = compptr->v_samp_factor;
      access_rows = block_rows; /* this iMCU row only */
+      last_row = TRUE;
    }
    /* Align the virtual buffer for this component. */
-    if (cinfo->output_iMCU_row > 1) {
-      access_rows += 2 * compptr->v_samp_factor; /* prior two iMCU rows too */
+    if (cinfo->output_iMCU_row > 0) {
+      access_rows += compptr->v_samp_factor; /* prior iMCU row too */
      buffer = (*cinfo->mem->access_virt_barray)
-        ((j_common_ptr)cinfo, coef->whole_image[ci],
-         (cinfo->output_iMCU_row - 2) * compptr->v_samp_factor,
-         (JDIMENSION)access_rows, FALSE);
-      buffer += 2 * compptr->v_samp_factor; /* point to current iMCU row */
-    } else if (cinfo->output_iMCU_row > 0) {
-      buffer = (*cinfo->mem->access_virt_barray)
-        ((j_common_ptr)cinfo, coef->whole_image[ci],
+        ((j_common_ptr) cinfo, coef->whole_image[ci],
         (cinfo->output_iMCU_row - 1) * compptr->v_samp_factor,
-         (JDIMENSION)access_rows, FALSE);
+         (JDIMENSION) access_rows, FALSE);
      buffer += compptr->v_samp_factor; /* point to current iMCU row */
+      first_row = FALSE;
    } else {
      buffer = (*cinfo->mem->access_virt_barray)
-        ((j_common_ptr)cinfo, coef->whole_image[ci],
-         (JDIMENSION)0, (JDIMENSION)access_rows, FALSE);
+        ((j_common_ptr) cinfo, coef->whole_image[ci],
+         (JDIMENSION) 0, (JDIMENSION) access_rows, FALSE);
+      first_row = TRUE;
    }
-    /* Fetch component-dependent info.
-     * If the current scan is incomplete, then we use the component-dependent
-     * info from the previous scan.
-     */
-    if (cinfo->output_iMCU_row > cinfo->master->last_good_iMCU_row)
-      coef_bits =
-        coef->coef_bits_latch + ((ci + cinfo->num_components) * SAVED_COEFS);
-    else
-      coef_bits = coef->coef_bits_latch + (ci * SAVED_COEFS);
-
-    /* We only do DC interpolation if no AC coefficient data is available. */
-    change_dc =
-      coef_bits[1] == -1 && coef_bits[2] == -1 && coef_bits[3] == -1 &&
-      coef_bits[4] == -1 && coef_bits[5] == -1 && coef_bits[6] == -1 &&
-      coef_bits[7] == -1 && coef_bits[8] == -1 && coef_bits[9] == -1;
-
+    /* Fetch component-dependent info */
+    coef_bits = coef->coef_bits_latch + (ci * SAVED_COEFS);
    quanttbl = compptr->quant_table;
    Q00 = quanttbl->quantval[0];
    Q01 = quanttbl->quantval[Q01_POS];
@@ -529,268 +488,124 @@ decompress_smooth_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
    Q20 = quanttbl->quantval[Q20_POS];
    Q11 = quanttbl->quantval[Q11_POS];
    Q02 = quanttbl->quantval[Q02_POS];
-    if (change_dc) {
-      Q03 = quanttbl->quantval[Q03_POS];
-      Q12 = quanttbl->quantval[Q12_POS];
-      Q21 = quanttbl->quantval[Q21_POS];
-      Q30 = quanttbl->quantval[Q30_POS];
-    }
    inverse_DCT = cinfo->idct->inverse_DCT[ci];
    output_ptr = output_buf[ci];
    /* Loop over all DCT blocks to be processed. */
    for (block_row = 0; block_row < block_rows; block_row++) {
      buffer_ptr = buffer[block_row] + cinfo->master->first_MCU_col[ci];
-
-      if (block_row > 0 || cinfo->output_iMCU_row > 0)
-        prev_block_row =
-          buffer[block_row - 1] + cinfo->master->first_MCU_col[ci];
-      else
+      if (first_row && block_row == 0)
        prev_block_row = buffer_ptr;
-
-      if (block_row > 1 || cinfo->output_iMCU_row > 1)
-        prev_prev_block_row =
-          buffer[block_row - 2] + cinfo->master->first_MCU_col[ci];
-      else
-        prev_prev_block_row = prev_block_row;
-
-      if (block_row < block_rows - 1 || cinfo->output_iMCU_row < last_iMCU_row)
-        next_block_row =
-          buffer[block_row + 1] + cinfo->master->first_MCU_col[ci];
      else
+        prev_block_row = buffer[block_row-1];
+      if (last_row && block_row == block_rows-1)
        next_block_row = buffer_ptr;
-
-      if (block_row < block_rows - 2 ||
-          cinfo->output_iMCU_row < last_iMCU_row - 1)
-        next_next_block_row =
-          buffer[block_row + 2] + cinfo->master->first_MCU_col[ci];
      else
-        next_next_block_row = next_block_row;
-
+        next_block_row = buffer[block_row+1];
      /* We fetch the surrounding DC values using a sliding-register approach.
-       * Initialize all 25 here so as to do the right thing on narrow pics.
+       * Initialize all nine here so as to do the right thing on narrow pics.
       */
-      DC01 = DC02 = DC03 = DC04 = DC05 = (int)prev_prev_block_row[0][0];
-      DC06 = DC07 = DC08 = DC09 = DC10 = (int)prev_block_row[0][0];
-      DC11 = DC12 = DC13 = DC14 = DC15 = (int)buffer_ptr[0][0];
-      DC16 = DC17 = DC18 = DC19 = DC20 = (int)next_block_row[0][0];
-      DC21 = DC22 = DC23 = DC24 = DC25 = (int)next_next_block_row[0][0];
+      DC1 = DC2 = DC3 = (int) prev_block_row[0][0];
+      DC4 = DC5 = DC6 = (int) buffer_ptr[0][0];
+      DC7 = DC8 = DC9 = (int) next_block_row[0][0];
      output_col = 0;
      last_block_column = compptr->width_in_blocks - 1;
      for (block_num = cinfo->master->first_MCU_col[ci];
           block_num <= cinfo->master->last_MCU_col[ci]; block_num++) {
        /* Fetch current DCT block into workspace so we can modify it. */
-        jcopy_block_row(buffer_ptr, (JBLOCKROW)workspace, (JDIMENSION)1);
+        jcopy_block_row(buffer_ptr, (JBLOCKROW) workspace, (JDIMENSION) 1);
        /* Update DC values */
-        if (block_num == cinfo->master->first_MCU_col[ci] &&
-            block_num < last_block_column) {
-          DC04 = (int)prev_prev_block_row[1][0];
-          DC09 = (int)prev_block_row[1][0];
-          DC14 = (int)buffer_ptr[1][0];
-          DC19 = (int)next_block_row[1][0];
-          DC24 = (int)next_next_block_row[1][0];
+        if (block_num < last_block_column) {
+          DC3 = (int) prev_block_row[1][0];
+          DC6 = (int) buffer_ptr[1][0];
+          DC9 = (int) next_block_row[1][0];
        }
-        if (block_num + 1 < last_block_column) {
-          DC05 = (int)prev_prev_block_row[2][0];
-          DC10 = (int)prev_block_row[2][0];
-          DC15 = (int)buffer_ptr[2][0];
-          DC20 = (int)next_block_row[2][0];
-          DC25 = (int)next_next_block_row[2][0];
-        }
-        /* If DC interpolation is enabled, compute coefficient estimates using
-         * a Gaussian-like kernel, keeping the averages of the DC values.
-         *
-         * If DC interpolation is disabled, compute coefficient estimates using
-         * an algorithm similar to the one described in Section K.8 of the JPEG
-         * standard, except applied to a 5x5 window rather than a 3x3 window.
-         *
-         * An estimate is applied only if the coefficient is still zero and is
-         * not known to be fully accurate.
+        /* Compute coefficient estimates per K.8.
+         * An estimate is applied only if coefficient is still zero,
+         * and is not known to be fully accurate.
         */
        /* AC01 */
-        if ((Al = coef_bits[1]) != 0 && workspace[1] == 0) {
-          num = Q00 * (change_dc ?
-                (-DC01 - DC02 + DC04 + DC05 - 3 * DC06 + 13 * DC07 -
-                 13 * DC09 + 3 * DC10 - 3 * DC11 + 38 * DC12 - 38 * DC14 +
-                 3 * DC15 - 3 * DC16 + 13 * DC17 - 13 * DC19 + 3 * DC20 -
-                 DC21 - DC22 + DC24 + DC25) :
-                (-7 * DC11 + 50 * DC12 - 50 * DC14 + 7 * DC15));
+        if ((Al=coef_bits[1]) != 0 && workspace[1] == 0) {
+          num = 36 * Q00 * (DC4 - DC6);
          if (num >= 0) {
-            pred = (int)(((Q01 << 7) + num) / (Q01 << 8));
-            if (Al > 0 && pred >= (1 << Al))
-              pred = (1 << Al) - 1;
+            pred = (int) (((Q01<<7) + num) / (Q01<<8));
+            if (Al > 0 && pred >= (1<<Al))
+              pred = (1<<Al)-1;
          } else {
-            pred = (int)(((Q01 << 7) - num) / (Q01 << 8));
-            if (Al > 0 && pred >= (1 << Al))
-              pred = (1 << Al) - 1;
+            pred = (int) (((Q01<<7) - num) / (Q01<<8));
+            if (Al > 0 && pred >= (1<<Al))
+              pred = (1<<Al)-1;
            pred = -pred;
          }
-          workspace[1] = (JCOEF)pred;
+          workspace[1] = (JCOEF) pred;
        }
        /* AC10 */
-        if ((Al = coef_bits[2]) != 0 && workspace[8] == 0) {
-          num = Q00 * (change_dc ?
-                (-DC01 - 3 * DC02 - 3 * DC03 - 3 * DC04 - DC05 - DC06 +
-                 13 * DC07 + 38 * DC08 + 13 * DC09 - DC10 + DC16 -
-                 13 * DC17 - 38 * DC18 - 13 * DC19 + DC20 + DC21 +
-                 3 * DC22 + 3 * DC23 + 3 * DC24 + DC25) :
-                (-7 * DC03 + 50 * DC08 - 50 * DC18 + 7 * DC23));
+        if ((Al=coef_bits[2]) != 0 && workspace[8] == 0) {
+          num = 36 * Q00 * (DC2 - DC8);
          if (num >= 0) {
-            pred = (int)(((Q10 << 7) + num) / (Q10 << 8));
-            if (Al > 0 && pred >= (1 << Al))
-              pred = (1 << Al) - 1;
+            pred = (int) (((Q10<<7) + num) / (Q10<<8));
+            if (Al > 0 && pred >= (1<<Al))
+              pred = (1<<Al)-1;
          } else {
-            pred = (int)(((Q10 << 7) - num) / (Q10 << 8));
-            if (Al > 0 && pred >= (1 << Al))
-              pred = (1 << Al) - 1;
+            pred = (int) (((Q10<<7) - num) / (Q10<<8));
+            if (Al > 0 && pred >= (1<<Al))
+              pred = (1<<Al)-1;
            pred = -pred;
          }
-          workspace[8] = (JCOEF)pred;
+          workspace[8] = (JCOEF) pred;
        }
        /* AC20 */
-        if ((Al = coef_bits[3]) != 0 && workspace[16] == 0) {
-          num = Q00 * (change_dc ?
-                (DC03 + 2 * DC07 + 7 * DC08 + 2 * DC09 - 5 * DC12 - 14 * DC13 -
-                 5 * DC14 + 2 * DC17 + 7 * DC18 + 2 * DC19 + DC23) :
-                (-DC03 + 13 * DC08 - 24 * DC13 + 13 * DC18 - DC23));
+        if ((Al=coef_bits[3]) != 0 && workspace[16] == 0) {
+          num = 9 * Q00 * (DC2 + DC8 - 2*DC5);
          if (num >= 0) {
-            pred = (int)(((Q20 << 7) + num) / (Q20 << 8));
-            if (Al > 0 && pred >= (1 << Al))
-              pred = (1 << Al) - 1;
+            pred = (int) (((Q20<<7) + num) / (Q20<<8));
+            if (Al > 0 && pred >= (1<<Al))
+              pred = (1<<Al)-1;
          } else {
-            pred = (int)(((Q20 << 7) - num) / (Q20 << 8));
-            if (Al > 0 && pred >= (1 << Al))
-              pred = (1 << Al) - 1;
+            pred = (int) (((Q20<<7) - num) / (Q20<<8));
+            if (Al > 0 && pred >= (1<<Al))
+              pred = (1<<Al)-1;
            pred = -pred;
          }
-          workspace[16] = (JCOEF)pred;
+          workspace[16] = (JCOEF) pred;
        }
        /* AC11 */
-        if ((Al = coef_bits[4]) != 0 && workspace[9] == 0) {
-          num = Q00 * (change_dc ?
-                (-DC01 + DC05 + 9 * DC07 - 9 * DC09 - 9 * DC17 +
-                 9 * DC19 + DC21 - DC25) :
-                (DC10 + DC16 - 10 * DC17 + 10 * DC19 - DC02 - DC20 + DC22 -
-                 DC24 + DC04 - DC06 + 10 * DC07 - 10 * DC09));
+        if ((Al=coef_bits[4]) != 0 && workspace[9] == 0) {
+          num = 5 * Q00 * (DC1 - DC3 - DC7 + DC9);
          if (num >= 0) {
-            pred = (int)(((Q11 << 7) + num) / (Q11 << 8));
-            if (Al > 0 && pred >= (1 << Al))
-              pred = (1 << Al) - 1;
+            pred = (int) (((Q11<<7) + num) / (Q11<<8));
+            if (Al > 0 && pred >= (1<<Al))
+              pred = (1<<Al)-1;
          } else {
-            pred = (int)(((Q11 << 7) - num) / (Q11 << 8));
-            if (Al > 0 && pred >= (1 << Al))
-              pred = (1 << Al) - 1;
+            pred = (int) (((Q11<<7) - num) / (Q11<<8));
+            if (Al > 0 && pred >= (1<<Al))
+              pred = (1<<Al)-1;
            pred = -pred;
          }
-          workspace[9] = (JCOEF)pred;
+          workspace[9] = (JCOEF) pred;
        }
        /* AC02 */
-        if ((Al = coef_bits[5]) != 0 && workspace[2] == 0) {
-          num = Q00 * (change_dc ?
-                (2 * DC07 - 5 * DC08 + 2 * DC09 + DC11 + 7 * DC12 - 14 * DC13 +
-                 7 * DC14 + DC15 + 2 * DC17 - 5 * DC18 + 2 * DC19) :
-                (-DC11 + 13 * DC12 - 24 * DC13 + 13 * DC14 - DC15));
+        if ((Al=coef_bits[5]) != 0 && workspace[2] == 0) {
+          num = 9 * Q00 * (DC4 + DC6 - 2*DC5);
          if (num >= 0) {
-            pred = (int)(((Q02 << 7) + num) / (Q02 << 8));
-            if (Al > 0 && pred >= (1 << Al))
-              pred = (1 << Al) - 1;
+            pred = (int) (((Q02<<7) + num) / (Q02<<8));
+            if (Al > 0 && pred >= (1<<Al))
+              pred = (1<<Al)-1;
          } else {
-            pred = (int)(((Q02 << 7) - num) / (Q02 << 8));
-            if (Al > 0 && pred >= (1 << Al))
-              pred = (1 << Al) - 1;
+            pred = (int) (((Q02<<7) - num) / (Q02<<8));
+            if (Al > 0 && pred >= (1<<Al))
+              pred = (1<<Al)-1;
            pred = -pred;
          }
-          workspace[2] = (JCOEF)pred;
+          workspace[2] = (JCOEF) pred;
        }
-        if (change_dc) {
-          /* AC03 */
-          if ((Al = coef_bits[6]) != 0 && workspace[3] == 0) {
-            num = Q00 * (DC07 - DC09 + 2 * DC12 - 2 * DC14 + DC17 - DC19);
-            if (num >= 0) {
-              pred = (int)(((Q03 << 7) + num) / (Q03 << 8));
-              if (Al > 0 && pred >= (1 << Al))
-                pred = (1 << Al) - 1;
-            } else {
-              pred = (int)(((Q03 << 7) - num) / (Q03 << 8));
-              if (Al > 0 && pred >= (1 << Al))
-                pred = (1 << Al) - 1;
-              pred = -pred;
-            }
-            workspace[3] = (JCOEF)pred;
-          }
-          /* AC12 */
-          if ((Al = coef_bits[7]) != 0 && workspace[10] == 0) {
-            num = Q00 * (DC07 - 3 * DC08 + DC09 - DC17 + 3 * DC18 - DC19);
-            if (num >= 0) {
-              pred = (int)(((Q12 << 7) + num) / (Q12 << 8));
-              if (Al > 0 && pred >= (1 << Al))
-                pred = (1 << Al) - 1;
-            } else {
-              pred = (int)(((Q12 << 7) - num) / (Q12 << 8));
-              if (Al > 0 && pred >= (1 << Al))
-                pred = (1 << Al) - 1;
-              pred = -pred;
-            }
-            workspace[10] = (JCOEF)pred;
-          }
-          /* AC21 */
-          if ((Al = coef_bits[8]) != 0 && workspace[17] == 0) {
-            num = Q00 * (DC07 - DC09 - 3 * DC12 + 3 * DC14 + DC17 - DC19);
-            if (num >= 0) {
-              pred = (int)(((Q21 << 7) + num) / (Q21 << 8));
-              if (Al > 0 && pred >= (1 << Al))
-                pred = (1 << Al) - 1;
-            } else {
-              pred = (int)(((Q21 << 7) - num) / (Q21 << 8));
-              if (Al > 0 && pred >= (1 << Al))
-                pred = (1 << Al) - 1;
-              pred = -pred;
-            }
-            workspace[17] = (JCOEF)pred;
-          }
-          /* AC30 */
-          if ((Al = coef_bits[9]) != 0 && workspace[24] == 0) {
-            num = Q00 * (DC07 + 2 * DC08 + DC09 - DC17 - 2 * DC18 - DC19);
-            if (num >= 0) {
-              pred = (int)(((Q30 << 7) + num) / (Q30 << 8));
-              if (Al > 0 && pred >= (1 << Al))
-                pred = (1 << Al) - 1;
-            } else {
-              pred = (int)(((Q30 << 7) - num) / (Q30 << 8));
-              if (Al > 0 && pred >= (1 << Al))
-                pred = (1 << Al) - 1;
-              pred = -pred;
-            }
-            workspace[24] = (JCOEF)pred;
-          }
-          /* coef_bits[0] is non-negative.  Otherwise this function would not
-           * be called.
-           */
-          num = Q00 *
-                (-2 * DC01 - 6 * DC02 - 8 * DC03 - 6 * DC04 - 2 * DC05 -
-                 6 * DC06 + 6 * DC07 + 42 * DC08 + 6 * DC09 - 6 * DC10 -
-                 8 * DC11 + 42 * DC12 + 152 * DC13 + 42 * DC14 - 8 * DC15 -
-                 6 * DC16 + 6 * DC17 + 42 * DC18 + 6 * DC19 - 6 * DC20 -
-                 2 * DC21 - 6 * DC22 - 8 * DC23 - 6 * DC24 - 2 * DC25);
-          if (num >= 0) {
-            pred = (int)(((Q00 << 7) + num) / (Q00 << 8));
-          } else {
-            pred = (int)(((Q00 << 7) - num) / (Q00 << 8));
-            pred = -pred;
-          }
-          workspace[0] = (JCOEF)pred;
-        }  /* change_dc */
-
        /* OK, do the IDCT */
-        (*inverse_DCT) (cinfo, compptr, (JCOEFPTR)workspace, output_ptr,
-                        output_col);
+        (*inverse_DCT) (cinfo, compptr, (JCOEFPTR) workspace,
+                        output_ptr, output_col);
        /* Advance for next column */
-        DC01 = DC02;  DC02 = DC03;  DC03 = DC04;  DC04 = DC05;
-        DC06 = DC07;  DC07 = DC08;  DC08 = DC09;  DC09 = DC10;
-        DC11 = DC12;  DC12 = DC13;  DC13 = DC14;  DC14 = DC15;
-        DC16 = DC17;  DC17 = DC18;  DC18 = DC19;  DC19 = DC20;
-        DC21 = DC22;  DC22 = DC23;  DC23 = DC24;  DC24 = DC25;
-        buffer_ptr++, prev_block_row++, next_block_row++,
-          prev_prev_block_row++, next_next_block_row++;
+        DC1 = DC2; DC2 = DC3;
+        DC4 = DC5; DC5 = DC6;
+        DC7 = DC8; DC8 = DC9;
+        buffer_ptr++, prev_block_row++, next_block_row++;
        output_col += compptr->_DCT_scaled_size;
      }
      output_ptr += compptr->_DCT_scaled_size;
@@ -810,14 +625,14 @@ decompress_smooth_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
 */

 GLOBAL(void)
-jinit_d_coef_controller(j_decompress_ptr cinfo, boolean need_full_buffer)
+jinit_d_coef_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
 {
  my_coef_ptr coef;

  coef = (my_coef_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                sizeof(my_coef_controller));
-  cinfo->coef = (struct jpeg_d_coef_controller *)coef;
+  cinfo->coef = (struct jpeg_d_coef_controller *) coef;
  coef->pub.start_input_pass = start_input_pass;
  coef->pub.start_output_pass = start_output_pass;
 #ifdef BLOCK_SMOOTHING_SUPPORTED
@@ -839,15 +654,15 @@ jinit_d_coef_controller(j_decompress_ptr cinfo, boolean need_full_buffer)
 #ifdef BLOCK_SMOOTHING_SUPPORTED
      /* If block smoothing could be used, need a bigger window */
      if (cinfo->progressive_mode)
-        access_rows *= 5;
+        access_rows *= 3;
 #endif
      coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
-        ((j_common_ptr)cinfo, JPOOL_IMAGE, TRUE,
-         (JDIMENSION)jround_up((long)compptr->width_in_blocks,
-                               (long)compptr->h_samp_factor),
-         (JDIMENSION)jround_up((long)compptr->height_in_blocks,
-                               (long)compptr->v_samp_factor),
-         (JDIMENSION)access_rows);
+        ((j_common_ptr) cinfo, JPOOL_IMAGE, TRUE,
+         (JDIMENSION) jround_up((long) compptr->width_in_blocks,
+                                (long) compptr->h_samp_factor),
+         (JDIMENSION) jround_up((long) compptr->height_in_blocks,
+                                (long) compptr->v_samp_factor),
+         (JDIMENSION) access_rows);
    }
    coef->pub.consume_data = consume_data;
    coef->pub.decompress_data = decompress_data;
@@ -861,7 +676,7 @@ jinit_d_coef_controller(j_decompress_ptr cinfo, boolean need_full_buffer)
    int i;

    buffer = (JBLOCKROW)
-      (*cinfo->mem->alloc_large) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+      (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                  D_MAX_BLOCKS_IN_MCU * sizeof(JBLOCK));
    for (i = 0; i < D_MAX_BLOCKS_IN_MCU; i++) {
      coef->MCU_buffer[i] = buffer + i;
@@ -873,6 +688,6 @@ jinit_d_coef_controller(j_decompress_ptr cinfo, boolean need_full_buffer)

  /* Allocate the workspace buffer */
  coef->workspace = (JCOEF *)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                sizeof(JCOEF) * DCTSIZE2);
 }
@@ -5,7 +5,6 @@
 * Copyright (C) 1994-1997, Thomas G. Lane.
 * libjpeg-turbo Modifications:
 * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
- * Copyright (C) 2020, Google, Inc.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
 */
@@ -52,7 +51,7 @@ typedef struct {
 #ifdef BLOCK_SMOOTHING_SUPPORTED
  /* When doing block smoothing, we latch coefficient Al values here */
  int *coef_bits_latch;
-#define SAVED_COEFS  10         /* we save coef_bits[0..9] */
+#define SAVED_COEFS  6          /* we save coef_bits[0..5] */
 #endif
 } my_coef_controller;

@@ -60,10 +59,10 @@ typedef my_coef_controller *my_coef_ptr;


 LOCAL(void)
-start_iMCU_row(j_decompress_ptr cinfo)
+start_iMCU_row (j_decompress_ptr cinfo)
 /* Reset within-iMCU-row counters for a new row (input side) */
 {
-  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;

  /* In an interleaved scan, an MCU row is the same as an iMCU row.
   * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
@@ -72,7 +71,7 @@ start_iMCU_row(j_decompress_ptr cinfo)
  if (cinfo->comps_in_scan > 1) {
    coef->MCU_rows_per_iMCU_row = 1;
  } else {
-    if (cinfo->input_iMCU_row < (cinfo->total_iMCU_rows - 1))
+    if (cinfo->input_iMCU_row < (cinfo->total_iMCU_rows-1))
      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
    else
      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
@@ -17,22 +17,22 @@

 INLINE
 LOCAL(void)
-ycc_rgb565_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                            JDIMENSION input_row, JSAMPARRAY output_buf,
-                            int num_rows)
+ycc_rgb565_convert_internal (j_decompress_ptr cinfo,
+                             JSAMPIMAGE input_buf, JDIMENSION input_row,
+                             JSAMPARRAY output_buf, int num_rows)
 {
-  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
  register int y, cb, cr;
  register JSAMPROW outptr;
  register JSAMPROW inptr0, inptr1, inptr2;
  register JDIMENSION col;
  JDIMENSION num_cols = cinfo->output_width;
  /* copy these pointers into registers if possible */
-  register JSAMPLE *range_limit = cinfo->sample_range_limit;
-  register int *Crrtab = cconvert->Cr_r_tab;
-  register int *Cbbtab = cconvert->Cb_b_tab;
-  register JLONG *Crgtab = cconvert->Cr_g_tab;
-  register JLONG *Cbgtab = cconvert->Cb_g_tab;
+  register JSAMPLE * range_limit = cinfo->sample_range_limit;
+  register int * Crrtab = cconvert->Cr_r_tab;
+  register int * Cbbtab = cconvert->Cb_b_tab;
+  register JLONG * Crgtab = cconvert->Cr_g_tab;
+  register JLONG * Cbgtab = cconvert->Cb_g_tab;
  SHIFT_TEMPS

  while (--num_rows >= 0) {
@@ -45,31 +45,31 @@ ycc_rgb565_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
    outptr = *output_buf++;

    if (PACK_NEED_ALIGNMENT(outptr)) {
-      y  = *inptr0++;
-      cb = *inptr1++;
-      cr = *inptr2++;
+      y  = GETJSAMPLE(*inptr0++);
+      cb = GETJSAMPLE(*inptr1++);
+      cr = GETJSAMPLE(*inptr2++);
      r = range_limit[y + Crrtab[cr]];
      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
                                            SCALEBITS))];
      b = range_limit[y + Cbbtab[cb]];
      rgb = PACK_SHORT_565(r, g, b);
-      *(INT16 *)outptr = (INT16)rgb;
+      *(INT16*)outptr = (INT16)rgb;
      outptr += 2;
      num_cols--;
    }
    for (col = 0; col < (num_cols >> 1); col++) {
-      y  = *inptr0++;
-      cb = *inptr1++;
-      cr = *inptr2++;
+      y  = GETJSAMPLE(*inptr0++);
+      cb = GETJSAMPLE(*inptr1++);
+      cr = GETJSAMPLE(*inptr2++);
      r = range_limit[y + Crrtab[cr]];
      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
                                            SCALEBITS))];
      b = range_limit[y + Cbbtab[cb]];
      rgb = PACK_SHORT_565(r, g, b);

-      y  = *inptr0++;
-      cb = *inptr1++;
-      cr = *inptr2++;
+      y  = GETJSAMPLE(*inptr0++);
+      cb = GETJSAMPLE(*inptr1++);
+      cr = GETJSAMPLE(*inptr2++);
      r = range_limit[y + Crrtab[cr]];
      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
                                            SCALEBITS))];
@@ -80,15 +80,15 @@ ycc_rgb565_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
      outptr += 4;
    }
    if (num_cols & 1) {
-      y  = *inptr0;
-      cb = *inptr1;
-      cr = *inptr2;
+      y  = GETJSAMPLE(*inptr0);
+      cb = GETJSAMPLE(*inptr1);
+      cr = GETJSAMPLE(*inptr2);
      r = range_limit[y + Crrtab[cr]];
      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
                                            SCALEBITS))];
      b = range_limit[y + Cbbtab[cb]];
      rgb = PACK_SHORT_565(r, g, b);
-      *(INT16 *)outptr = (INT16)rgb;
+      *(INT16*)outptr = (INT16)rgb;
    }
  }
 }
@@ -96,22 +96,22 @@ ycc_rgb565_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,

 INLINE
 LOCAL(void)
-ycc_rgb565D_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                             JDIMENSION input_row, JSAMPARRAY output_buf,
-                             int num_rows)
+ycc_rgb565D_convert_internal (j_decompress_ptr cinfo,
+                              JSAMPIMAGE input_buf, JDIMENSION input_row,
+                              JSAMPARRAY output_buf, int num_rows)
 {
-  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
  register int y, cb, cr;
  register JSAMPROW outptr;
  register JSAMPROW inptr0, inptr1, inptr2;
  register JDIMENSION col;
  JDIMENSION num_cols = cinfo->output_width;
  /* copy these pointers into registers if possible */
-  register JSAMPLE *range_limit = cinfo->sample_range_limit;
-  register int *Crrtab = cconvert->Cr_r_tab;
-  register int *Cbbtab = cconvert->Cb_b_tab;
-  register JLONG *Crgtab = cconvert->Cr_g_tab;
-  register JLONG *Cbgtab = cconvert->Cb_g_tab;
+  register JSAMPLE * range_limit = cinfo->sample_range_limit;
+  register int * Crrtab = cconvert->Cr_r_tab;
+  register int * Cbbtab = cconvert->Cb_b_tab;
+  register JLONG * Crgtab = cconvert->Cr_g_tab;
+  register JLONG * Cbgtab = cconvert->Cb_g_tab;
  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];
  SHIFT_TEMPS

@@ -125,23 +125,23 @@ ycc_rgb565D_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
    input_row++;
    outptr = *output_buf++;
    if (PACK_NEED_ALIGNMENT(outptr)) {
-      y  = *inptr0++;
-      cb = *inptr1++;
-      cr = *inptr2++;
+      y  = GETJSAMPLE(*inptr0++);
+      cb = GETJSAMPLE(*inptr1++);
+      cr = GETJSAMPLE(*inptr2++);
      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];
      g = range_limit[DITHER_565_G(y +
                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
                                                     SCALEBITS)), d0)];
      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];
      rgb = PACK_SHORT_565(r, g, b);
-      *(INT16 *)outptr = (INT16)rgb;
+      *(INT16*)outptr = (INT16)rgb;
      outptr += 2;
      num_cols--;
    }
    for (col = 0; col < (num_cols >> 1); col++) {
-      y  = *inptr0++;
-      cb = *inptr1++;
-      cr = *inptr2++;
+      y  = GETJSAMPLE(*inptr0++);
+      cb = GETJSAMPLE(*inptr1++);
+      cr = GETJSAMPLE(*inptr2++);
      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];
      g = range_limit[DITHER_565_G(y +
                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
@@ -150,9 +150,9 @@ ycc_rgb565D_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
      d0 = DITHER_ROTATE(d0);
      rgb = PACK_SHORT_565(r, g, b);

-      y  = *inptr0++;
-      cb = *inptr1++;
-      cr = *inptr2++;
+      y  = GETJSAMPLE(*inptr0++);
+      cb = GETJSAMPLE(*inptr1++);
+      cr = GETJSAMPLE(*inptr2++);
      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];
      g = range_limit[DITHER_565_G(y +
                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
@@ -165,16 +165,16 @@ ycc_rgb565D_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
      outptr += 4;
    }
    if (num_cols & 1) {
-      y  = *inptr0;
-      cb = *inptr1;
-      cr = *inptr2;
+      y  = GETJSAMPLE(*inptr0);
+      cb = GETJSAMPLE(*inptr1);
+      cr = GETJSAMPLE(*inptr2);
      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];
      g = range_limit[DITHER_565_G(y +
                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
                                                     SCALEBITS)), d0)];
      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];
      rgb = PACK_SHORT_565(r, g, b);
-      *(INT16 *)outptr = (INT16)rgb;
+      *(INT16*)outptr = (INT16)rgb;
    }
  }
 }
@@ -182,9 +182,9 @@ ycc_rgb565D_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,

 INLINE
 LOCAL(void)
-rgb_rgb565_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                            JDIMENSION input_row, JSAMPARRAY output_buf,
-                            int num_rows)
+rgb_rgb565_convert_internal (j_decompress_ptr cinfo,
+                             JSAMPIMAGE input_buf, JDIMENSION input_row,
+                             JSAMPARRAY output_buf, int num_rows)
 {
  register JSAMPROW outptr;
  register JSAMPROW inptr0, inptr1, inptr2;
@@ -202,34 +202,34 @@ rgb_rgb565_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
    input_row++;
    outptr = *output_buf++;
    if (PACK_NEED_ALIGNMENT(outptr)) {
-      r = *inptr0++;
-      g = *inptr1++;
-      b = *inptr2++;
+      r = GETJSAMPLE(*inptr0++);
+      g = GETJSAMPLE(*inptr1++);
+      b = GETJSAMPLE(*inptr2++);
      rgb = PACK_SHORT_565(r, g, b);
-      *(INT16 *)outptr = (INT16)rgb;
+      *(INT16*)outptr = (INT16)rgb;
      outptr += 2;
      num_cols--;
    }
    for (col = 0; col < (num_cols >> 1); col++) {
-      r = *inptr0++;
-      g = *inptr1++;
-      b = *inptr2++;
+      r = GETJSAMPLE(*inptr0++);
+      g = GETJSAMPLE(*inptr1++);
+      b = GETJSAMPLE(*inptr2++);
      rgb = PACK_SHORT_565(r, g, b);

-      r = *inptr0++;
-      g = *inptr1++;
-      b = *inptr2++;
+      r = GETJSAMPLE(*inptr0++);
+      g = GETJSAMPLE(*inptr1++);
+      b = GETJSAMPLE(*inptr2++);
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
      outptr += 4;
    }
    if (num_cols & 1) {
-      r = *inptr0;
-      g = *inptr1;
-      b = *inptr2;
+      r = GETJSAMPLE(*inptr0);
+      g = GETJSAMPLE(*inptr1);
+      b = GETJSAMPLE(*inptr2);
      rgb = PACK_SHORT_565(r, g, b);
-      *(INT16 *)outptr = (INT16)rgb;
+      *(INT16*)outptr = (INT16)rgb;
    }
  }
 }
@@ -237,14 +237,14 @@ rgb_rgb565_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,

 INLINE
 LOCAL(void)
-rgb_rgb565D_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                             JDIMENSION input_row, JSAMPARRAY output_buf,
-                             int num_rows)
+rgb_rgb565D_convert_internal (j_decompress_ptr cinfo,
+                              JSAMPIMAGE input_buf, JDIMENSION input_row,
+                              JSAMPARRAY output_buf, int num_rows)
 {
  register JSAMPROW outptr;
  register JSAMPROW inptr0, inptr1, inptr2;
  register JDIMENSION col;
-  register JSAMPLE *range_limit = cinfo->sample_range_limit;
+  register JSAMPLE * range_limit = cinfo->sample_range_limit;
  JDIMENSION num_cols = cinfo->output_width;
  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];
  SHIFT_TEMPS
@@ -259,24 +259,24 @@ rgb_rgb565D_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
    input_row++;
    outptr = *output_buf++;
    if (PACK_NEED_ALIGNMENT(outptr)) {
-      r = range_limit[DITHER_565_R(*inptr0++, d0)];
-      g = range_limit[DITHER_565_G(*inptr1++, d0)];
-      b = range_limit[DITHER_565_B(*inptr2++, d0)];
+      r = range_limit[DITHER_565_R(GETJSAMPLE(*inptr0++), d0)];
+      g = range_limit[DITHER_565_G(GETJSAMPLE(*inptr1++), d0)];
+      b = range_limit[DITHER_565_B(GETJSAMPLE(*inptr2++), d0)];
      rgb = PACK_SHORT_565(r, g, b);
-      *(INT16 *)outptr = (INT16)rgb;
+      *(INT16*)outptr = (INT16)rgb;
      outptr += 2;
      num_cols--;
    }
    for (col = 0; col < (num_cols >> 1); col++) {
-      r = range_limit[DITHER_565_R(*inptr0++, d0)];
-      g = range_limit[DITHER_565_G(*inptr1++, d0)];
-      b = range_limit[DITHER_565_B(*inptr2++, d0)];
+      r = range_limit[DITHER_565_R(GETJSAMPLE(*inptr0++), d0)];
+      g = range_limit[DITHER_565_G(GETJSAMPLE(*inptr1++), d0)];
+      b = range_limit[DITHER_565_B(GETJSAMPLE(*inptr2++), d0)];
      d0 = DITHER_ROTATE(d0);
      rgb = PACK_SHORT_565(r, g, b);

-      r = range_limit[DITHER_565_R(*inptr0++, d0)];
-      g = range_limit[DITHER_565_G(*inptr1++, d0)];
-      b = range_limit[DITHER_565_B(*inptr2++, d0)];
+      r = range_limit[DITHER_565_R(GETJSAMPLE(*inptr0++), d0)];
+      g = range_limit[DITHER_565_G(GETJSAMPLE(*inptr1++), d0)];
+      b = range_limit[DITHER_565_B(GETJSAMPLE(*inptr2++), d0)];
      d0 = DITHER_ROTATE(d0);
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));

@@ -284,11 +284,11 @@ rgb_rgb565D_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
      outptr += 4;
    }
    if (num_cols & 1) {
-      r = range_limit[DITHER_565_R(*inptr0, d0)];
-      g = range_limit[DITHER_565_G(*inptr1, d0)];
-      b = range_limit[DITHER_565_B(*inptr2, d0)];
+      r = range_limit[DITHER_565_R(GETJSAMPLE(*inptr0), d0)];
+      g = range_limit[DITHER_565_G(GETJSAMPLE(*inptr1), d0)];
+      b = range_limit[DITHER_565_B(GETJSAMPLE(*inptr2), d0)];
      rgb = PACK_SHORT_565(r, g, b);
-      *(INT16 *)outptr = (INT16)rgb;
+      *(INT16*)outptr = (INT16)rgb;
    }
  }
 }
@@ -296,9 +296,9 @@ rgb_rgb565D_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,

 INLINE
 LOCAL(void)
-gray_rgb565_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                             JDIMENSION input_row, JSAMPARRAY output_buf,
-                             int num_rows)
+gray_rgb565_convert_internal (j_decompress_ptr cinfo,
+                              JSAMPIMAGE input_buf, JDIMENSION input_row,
+                              JSAMPARRAY output_buf, int num_rows)
 {
  register JSAMPROW inptr, outptr;
  register JDIMENSION col;
@@ -313,7 +313,7 @@ gray_rgb565_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
    if (PACK_NEED_ALIGNMENT(outptr)) {
      g = *inptr++;
      rgb = PACK_SHORT_565(g, g, g);
-      *(INT16 *)outptr = (INT16)rgb;
+      *(INT16*)outptr = (INT16)rgb;
      outptr += 2;
      num_cols--;
    }
@@ -328,7 +328,7 @@ gray_rgb565_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
    if (num_cols & 1) {
      g = *inptr;
      rgb = PACK_SHORT_565(g, g, g);
-      *(INT16 *)outptr = (INT16)rgb;
+      *(INT16*)outptr = (INT16)rgb;
    }
  }
 }
@@ -336,13 +336,13 @@ gray_rgb565_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,

 INLINE
 LOCAL(void)
-gray_rgb565D_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                              JDIMENSION input_row, JSAMPARRAY output_buf,
-                              int num_rows)
+gray_rgb565D_convert_internal (j_decompress_ptr cinfo,
+                               JSAMPIMAGE input_buf, JDIMENSION input_row,
+                               JSAMPARRAY output_buf, int num_rows)
 {
  register JSAMPROW inptr, outptr;
  register JDIMENSION col;
-  register JSAMPLE *range_limit = cinfo->sample_range_limit;
+  register JSAMPLE * range_limit = cinfo->sample_range_limit;
  JDIMENSION num_cols = cinfo->output_width;
  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];

@@ -356,7 +356,7 @@ gray_rgb565D_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
      g = *inptr++;
      g = range_limit[DITHER_565_R(g, d0)];
      rgb = PACK_SHORT_565(g, g, g);
-      *(INT16 *)outptr = (INT16)rgb;
+      *(INT16*)outptr = (INT16)rgb;
      outptr += 2;
      num_cols--;
    }
@@ -378,7 +378,7 @@ gray_rgb565D_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
      g = *inptr;
      g = range_limit[DITHER_565_R(g, d0)];
      rgb = PACK_SHORT_565(g, g, g);
-      *(INT16 *)outptr = (INT16)rgb;
+      *(INT16*)outptr = (INT16)rgb;
    }
  }
 }
@@ -28,22 +28,22 @@

 INLINE
 LOCAL(void)
-ycc_rgb_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                         JDIMENSION input_row, JSAMPARRAY output_buf,
-                         int num_rows)
+ycc_rgb_convert_internal (j_decompress_ptr cinfo,
+                          JSAMPIMAGE input_buf, JDIMENSION input_row,
+                          JSAMPARRAY output_buf, int num_rows)
 {
-  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
  register int y, cb, cr;
  register JSAMPROW outptr;
  register JSAMPROW inptr0, inptr1, inptr2;
  register JDIMENSION col;
  JDIMENSION num_cols = cinfo->output_width;
  /* copy these pointers into registers if possible */
-  register JSAMPLE *range_limit = cinfo->sample_range_limit;
-  register int *Crrtab = cconvert->Cr_r_tab;
-  register int *Cbbtab = cconvert->Cb_b_tab;
-  register JLONG *Crgtab = cconvert->Cr_g_tab;
-  register JLONG *Cbgtab = cconvert->Cb_g_tab;
+  register JSAMPLE * range_limit = cinfo->sample_range_limit;
+  register int * Crrtab = cconvert->Cr_r_tab;
+  register int * Cbbtab = cconvert->Cb_b_tab;
+  register JLONG * Crgtab = cconvert->Cr_g_tab;
+  register JLONG * Cbgtab = cconvert->Cb_g_tab;
  SHIFT_TEMPS

  while (--num_rows >= 0) {
@@ -53,14 +53,14 @@ ycc_rgb_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
    input_row++;
    outptr = *output_buf++;
    for (col = 0; col < num_cols; col++) {
-      y  = inptr0[col];
-      cb = inptr1[col];
-      cr = inptr2[col];
+      y  = GETJSAMPLE(inptr0[col]);
+      cb = GETJSAMPLE(inptr1[col]);
+      cr = GETJSAMPLE(inptr2[col]);
      /* Range-limiting is essential due to noise introduced by DCT losses. */
      outptr[RGB_RED] =   range_limit[y + Crrtab[cr]];
      outptr[RGB_GREEN] = range_limit[y +
-                              ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
-                                                SCALEBITS))];
+                              ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
+                                                 SCALEBITS))];
      outptr[RGB_BLUE] =  range_limit[y + Cbbtab[cb]];
      /* Set unused byte to 0xFF so it can be interpreted as an opaque */
      /* alpha channel value */
@@ -81,9 +81,9 @@ ycc_rgb_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,

 INLINE
 LOCAL(void)
-gray_rgb_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                          JDIMENSION input_row, JSAMPARRAY output_buf,
-                          int num_rows)
+gray_rgb_convert_internal (j_decompress_ptr cinfo,
+                           JSAMPIMAGE input_buf, JDIMENSION input_row,
+                           JSAMPARRAY output_buf, int num_rows)
 {
  register JSAMPROW inptr, outptr;
  register JDIMENSION col;
@@ -93,6 +93,7 @@ gray_rgb_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
    inptr = input_buf[0][input_row++];
    outptr = *output_buf++;
    for (col = 0; col < num_cols; col++) {
+      /* We can dispense with GETJSAMPLE() here */
      outptr[RGB_RED] = outptr[RGB_GREEN] = outptr[RGB_BLUE] = inptr[col];
      /* Set unused byte to 0xFF so it can be interpreted as an opaque */
      /* alpha channel value */
@@ -111,9 +112,9 @@ gray_rgb_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,

 INLINE
 LOCAL(void)
-rgb_rgb_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                         JDIMENSION input_row, JSAMPARRAY output_buf,
-                         int num_rows)
+rgb_rgb_convert_internal (j_decompress_ptr cinfo,
+                          JSAMPIMAGE input_buf, JDIMENSION input_row,
+                          JSAMPARRAY output_buf, int num_rows)
 {
  register JSAMPROW inptr0, inptr1, inptr2;
  register JSAMPROW outptr;
@@ -127,6 +128,7 @@ rgb_rgb_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
    input_row++;
    outptr = *output_buf++;
    for (col = 0; col < num_cols; col++) {
+      /* We can dispense with GETJSAMPLE() here */
      outptr[RGB_RED] = inptr0[col];
      outptr[RGB_GREEN] = inptr1[col];
      outptr[RGB_BLUE] = inptr2[col];
@@ -74,8 +74,8 @@ typedef my_color_deconverter *my_cconvert_ptr;
 */

 #define SCALEBITS       16      /* speediest right-shift on some machines */
-#define ONE_HALF        ((JLONG)1 << (SCALEBITS - 1))
-#define FIX(x)          ((JLONG)((x) * (1L << SCALEBITS) + 0.5))
+#define ONE_HALF        ((JLONG) 1 << (SCALEBITS-1))
+#define FIX(x)          ((JLONG) ((x) * (1L<<SCALEBITS) + 0.5))

 /* We allocate one big table for RGB->Y conversion and divide it up into
 * three parts, instead of doing three alloc_small requests.  This lets us
@@ -85,9 +85,9 @@ typedef my_color_deconverter *my_cconvert_ptr;
 */

 #define R_Y_OFF         0                       /* offset to R => Y section */
-#define G_Y_OFF         (1 * (MAXJSAMPLE + 1))  /* offset to G => Y section */
-#define B_Y_OFF         (2 * (MAXJSAMPLE + 1))  /* etc. */
-#define TABLE_SIZE      (3 * (MAXJSAMPLE + 1))
+#define G_Y_OFF         (1*(MAXJSAMPLE+1))      /* offset to G => Y section */
+#define B_Y_OFF         (2*(MAXJSAMPLE+1))      /* etc. */
+#define TABLE_SIZE      (3*(MAXJSAMPLE+1))


 /* Include inline routines for colorspace extensions */
@@ -98,13 +98,13 @@ typedef my_color_deconverter *my_cconvert_ptr;
 #undef RGB_BLUE
 #undef RGB_PIXELSIZE

-#define RGB_RED  EXT_RGB_RED
-#define RGB_GREEN  EXT_RGB_GREEN
-#define RGB_BLUE  EXT_RGB_BLUE
-#define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
-#define ycc_rgb_convert_internal  ycc_extrgb_convert_internal
-#define gray_rgb_convert_internal  gray_extrgb_convert_internal
-#define rgb_rgb_convert_internal  rgb_extrgb_convert_internal
+#define RGB_RED EXT_RGB_RED
+#define RGB_GREEN EXT_RGB_GREEN
+#define RGB_BLUE EXT_RGB_BLUE
+#define RGB_PIXELSIZE EXT_RGB_PIXELSIZE
+#define ycc_rgb_convert_internal ycc_extrgb_convert_internal
+#define gray_rgb_convert_internal gray_extrgb_convert_internal
+#define rgb_rgb_convert_internal rgb_extrgb_convert_internal
 #include "jdcolext.c"
 #undef RGB_RED
 #undef RGB_GREEN
@@ -114,14 +114,14 @@ typedef my_color_deconverter *my_cconvert_ptr;
 #undef gray_rgb_convert_internal
 #undef rgb_rgb_convert_internal

-#define RGB_RED  EXT_RGBX_RED
-#define RGB_GREEN  EXT_RGBX_GREEN
-#define RGB_BLUE  EXT_RGBX_BLUE
-#define RGB_ALPHA  3
-#define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
-#define ycc_rgb_convert_internal  ycc_extrgbx_convert_internal
-#define gray_rgb_convert_internal  gray_extrgbx_convert_internal
-#define rgb_rgb_convert_internal  rgb_extrgbx_convert_internal
+#define RGB_RED EXT_RGBX_RED
+#define RGB_GREEN EXT_RGBX_GREEN
+#define RGB_BLUE EXT_RGBX_BLUE
+#define RGB_ALPHA 3
+#define RGB_PIXELSIZE EXT_RGBX_PIXELSIZE
+#define ycc_rgb_convert_internal ycc_extrgbx_convert_internal
+#define gray_rgb_convert_internal gray_extrgbx_convert_internal
+#define rgb_rgb_convert_internal rgb_extrgbx_convert_internal
 #include "jdcolext.c"
 #undef RGB_RED
 #undef RGB_GREEN
@@ -132,13 +132,13 @@ typedef my_color_deconverter *my_cconvert_ptr;
 #undef gray_rgb_convert_internal
 #undef rgb_rgb_convert_internal

-#define RGB_RED  EXT_BGR_RED
-#define RGB_GREEN  EXT_BGR_GREEN
-#define RGB_BLUE  EXT_BGR_BLUE
-#define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
-#define ycc_rgb_convert_internal  ycc_extbgr_convert_internal
-#define gray_rgb_convert_internal  gray_extbgr_convert_internal
-#define rgb_rgb_convert_internal  rgb_extbgr_convert_internal
+#define RGB_RED EXT_BGR_RED
+#define RGB_GREEN EXT_BGR_GREEN
+#define RGB_BLUE EXT_BGR_BLUE
+#define RGB_PIXELSIZE EXT_BGR_PIXELSIZE
+#define ycc_rgb_convert_internal ycc_extbgr_convert_internal
+#define gray_rgb_convert_internal gray_extbgr_convert_internal
+#define rgb_rgb_convert_internal rgb_extbgr_convert_internal
 #include "jdcolext.c"
 #undef RGB_RED
 #undef RGB_GREEN
@@ -148,14 +148,14 @@ typedef my_color_deconverter *my_cconvert_ptr;
 #undef gray_rgb_convert_internal
 #undef rgb_rgb_convert_internal

-#define RGB_RED  EXT_BGRX_RED
-#define RGB_GREEN  EXT_BGRX_GREEN
-#define RGB_BLUE  EXT_BGRX_BLUE
-#define RGB_ALPHA  3
-#define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
-#define ycc_rgb_convert_internal  ycc_extbgrx_convert_internal
-#define gray_rgb_convert_internal  gray_extbgrx_convert_internal
-#define rgb_rgb_convert_internal  rgb_extbgrx_convert_internal
+#define RGB_RED EXT_BGRX_RED
+#define RGB_GREEN EXT_BGRX_GREEN
+#define RGB_BLUE EXT_BGRX_BLUE
+#define RGB_ALPHA 3
+#define RGB_PIXELSIZE EXT_BGRX_PIXELSIZE
+#define ycc_rgb_convert_internal ycc_extbgrx_convert_internal
+#define gray_rgb_convert_internal gray_extbgrx_convert_internal
+#define rgb_rgb_convert_internal rgb_extbgrx_convert_internal
 #include "jdcolext.c"
 #undef RGB_RED
 #undef RGB_GREEN
@@ -166,14 +166,14 @@ typedef my_color_deconverter *my_cconvert_ptr;
 #undef gray_rgb_convert_internal
 #undef rgb_rgb_convert_internal

-#define RGB_RED  EXT_XBGR_RED
-#define RGB_GREEN  EXT_XBGR_GREEN
-#define RGB_BLUE  EXT_XBGR_BLUE
-#define RGB_ALPHA  0
-#define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
-#define ycc_rgb_convert_internal  ycc_extxbgr_convert_internal
-#define gray_rgb_convert_internal  gray_extxbgr_convert_internal
-#define rgb_rgb_convert_internal  rgb_extxbgr_convert_internal
+#define RGB_RED EXT_XBGR_RED
+#define RGB_GREEN EXT_XBGR_GREEN
+#define RGB_BLUE EXT_XBGR_BLUE
+#define RGB_ALPHA 0
+#define RGB_PIXELSIZE EXT_XBGR_PIXELSIZE
+#define ycc_rgb_convert_internal ycc_extxbgr_convert_internal
+#define gray_rgb_convert_internal gray_extxbgr_convert_internal
+#define rgb_rgb_convert_internal rgb_extxbgr_convert_internal
 #include "jdcolext.c"
 #undef RGB_RED
 #undef RGB_GREEN
@@ -184,14 +184,14 @@ typedef my_color_deconverter *my_cconvert_ptr;
 #undef gray_rgb_convert_internal
 #undef rgb_rgb_convert_internal

-#define RGB_RED  EXT_XRGB_RED
-#define RGB_GREEN  EXT_XRGB_GREEN
-#define RGB_BLUE  EXT_XRGB_BLUE
-#define RGB_ALPHA  0
-#define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
-#define ycc_rgb_convert_internal  ycc_extxrgb_convert_internal
-#define gray_rgb_convert_internal  gray_extxrgb_convert_internal
-#define rgb_rgb_convert_internal  rgb_extxrgb_convert_internal
+#define RGB_RED EXT_XRGB_RED
+#define RGB_GREEN EXT_XRGB_GREEN
+#define RGB_BLUE EXT_XRGB_BLUE
+#define RGB_ALPHA 0
+#define RGB_PIXELSIZE EXT_XRGB_PIXELSIZE
+#define ycc_rgb_convert_internal ycc_extxrgb_convert_internal
+#define gray_rgb_convert_internal gray_extxrgb_convert_internal
+#define rgb_rgb_convert_internal rgb_extxrgb_convert_internal
 #include "jdcolext.c"
 #undef RGB_RED
 #undef RGB_GREEN
@@ -208,25 +208,25 @@ typedef my_color_deconverter *my_cconvert_ptr;
 */

 LOCAL(void)
-build_ycc_rgb_table(j_decompress_ptr cinfo)
+build_ycc_rgb_table (j_decompress_ptr cinfo)
 {
-  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
  int i;
  JLONG x;
  SHIFT_TEMPS

  cconvert->Cr_r_tab = (int *)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                (MAXJSAMPLE + 1) * sizeof(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));
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+                                (MAXJSAMPLE+1) * sizeof(int));
  cconvert->Cr_g_tab = (JLONG *)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                (MAXJSAMPLE + 1) * sizeof(JLONG));
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+                                (MAXJSAMPLE+1) * sizeof(JLONG));
  cconvert->Cb_g_tab = (JLONG *)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                (MAXJSAMPLE + 1) * sizeof(JLONG));
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+                                (MAXJSAMPLE+1) * sizeof(JLONG));

  for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
    /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
@@ -238,10 +238,10 @@ build_ycc_rgb_table(j_decompress_ptr cinfo)
    cconvert->Cb_b_tab[i] = (int)
                    RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
    /* Cr=>G value is scaled-up -0.71414 * x */
-    cconvert->Cr_g_tab[i] = (-FIX(0.71414)) * x;
+    cconvert->Cr_g_tab[i] = (- FIX(0.71414)) * x;
    /* Cb=>G value is scaled-up -0.34414 * x */
    /* We also add in ONE_HALF so that need not do it in inner loop */
-    cconvert->Cb_g_tab[i] = (-FIX(0.34414)) * x + ONE_HALF;
+    cconvert->Cb_g_tab[i] = (- FIX(0.34414)) * x + ONE_HALF;
  }
 }

@@ -251,42 +251,43 @@ build_ycc_rgb_table(j_decompress_ptr cinfo)
 */

 METHODDEF(void)
-ycc_rgb_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+ycc_rgb_convert (j_decompress_ptr cinfo,
+                 JSAMPIMAGE input_buf, JDIMENSION input_row,
+                 JSAMPARRAY output_buf, int num_rows)
 {
  switch (cinfo->out_color_space) {
-  case JCS_EXT_RGB:
-    ycc_extrgb_convert_internal(cinfo, input_buf, input_row, output_buf,
-                                num_rows);
-    break;
-  case JCS_EXT_RGBX:
-  case JCS_EXT_RGBA:
-    ycc_extrgbx_convert_internal(cinfo, input_buf, input_row, output_buf,
-                                 num_rows);
-    break;
-  case JCS_EXT_BGR:
-    ycc_extbgr_convert_internal(cinfo, input_buf, input_row, output_buf,
-                                num_rows);
-    break;
-  case JCS_EXT_BGRX:
-  case JCS_EXT_BGRA:
-    ycc_extbgrx_convert_internal(cinfo, input_buf, input_row, output_buf,
-                                 num_rows);
-    break;
-  case JCS_EXT_XBGR:
-  case JCS_EXT_ABGR:
-    ycc_extxbgr_convert_internal(cinfo, input_buf, input_row, output_buf,
-                                 num_rows);
-    break;
-  case JCS_EXT_XRGB:
-  case JCS_EXT_ARGB:
-    ycc_extxrgb_convert_internal(cinfo, input_buf, input_row, output_buf,
-                                 num_rows);
-    break;
-  default:
-    ycc_rgb_convert_internal(cinfo, input_buf, input_row, output_buf,
-                             num_rows);
-    break;
+    case JCS_EXT_RGB:
+      ycc_extrgb_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                  num_rows);
+      break;
+    case JCS_EXT_RGBX:
+    case JCS_EXT_RGBA:
+      ycc_extrgbx_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                   num_rows);
+      break;
+    case JCS_EXT_BGR:
+      ycc_extbgr_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                  num_rows);
+      break;
+    case JCS_EXT_BGRX:
+    case JCS_EXT_BGRA:
+      ycc_extbgrx_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                   num_rows);
+      break;
+    case JCS_EXT_XBGR:
+    case JCS_EXT_ABGR:
+      ycc_extxbgr_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                   num_rows);
+      break;
+    case JCS_EXT_XRGB:
+    case JCS_EXT_ARGB:
+      ycc_extxrgb_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                   num_rows);
+      break;
+    default:
+      ycc_rgb_convert_internal(cinfo, input_buf, input_row, output_buf,
+                               num_rows);
+      break;
  }
 }

@@ -299,21 +300,21 @@ ycc_rgb_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 */

 LOCAL(void)
-build_rgb_y_table(j_decompress_ptr cinfo)
+build_rgb_y_table (j_decompress_ptr cinfo)
 {
-  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
  JLONG *rgb_y_tab;
  JLONG i;

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

  for (i = 0; i <= MAXJSAMPLE; i++) {
-    rgb_y_tab[i + R_Y_OFF] = FIX(0.29900) * i;
-    rgb_y_tab[i + G_Y_OFF] = FIX(0.58700) * i;
-    rgb_y_tab[i + B_Y_OFF] = FIX(0.11400) * i + ONE_HALF;
+    rgb_y_tab[i+R_Y_OFF] = FIX(0.29900) * i;
+    rgb_y_tab[i+G_Y_OFF] = FIX(0.58700) * i;
+    rgb_y_tab[i+B_Y_OFF] = FIX(0.11400) * i + ONE_HALF;
  }
 }

@@ -323,10 +324,11 @@ build_rgb_y_table(j_decompress_ptr cinfo)
 */

 METHODDEF(void)
-rgb_gray_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                 JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+rgb_gray_convert (j_decompress_ptr cinfo,
+                  JSAMPIMAGE input_buf, JDIMENSION input_row,
+                  JSAMPARRAY output_buf, int num_rows)
 {
-  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
  register int r, g, b;
  register JLONG *ctab = cconvert->rgb_y_tab;
  register JSAMPROW outptr;
@@ -341,12 +343,13 @@ rgb_gray_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
    input_row++;
    outptr = *output_buf++;
    for (col = 0; col < num_cols; col++) {
-      r = inptr0[col];
-      g = inptr1[col];
-      b = inptr2[col];
+      r = GETJSAMPLE(inptr0[col]);
+      g = GETJSAMPLE(inptr1[col]);
+      b = GETJSAMPLE(inptr2[col]);
      /* Y */
-      outptr[col] = (JSAMPLE)((ctab[r + R_Y_OFF] + ctab[g + G_Y_OFF] +
-                               ctab[b + B_Y_OFF]) >> SCALEBITS);
+      outptr[col] = (JSAMPLE)
+                ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+                 >> SCALEBITS);
    }
  }
 }
@@ -358,8 +361,9 @@ rgb_gray_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 */

 METHODDEF(void)
-null_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-             JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+null_convert (j_decompress_ptr cinfo,
+              JSAMPIMAGE input_buf, JDIMENSION input_row,
+              JSAMPARRAY output_buf, int num_rows)
 {
  register JSAMPROW inptr, inptr0, inptr1, inptr2, inptr3, outptr;
  register JDIMENSION col;
@@ -419,11 +423,12 @@ null_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 */

 METHODDEF(void)
-grayscale_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                  JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+grayscale_convert (j_decompress_ptr cinfo,
+                   JSAMPIMAGE input_buf, JDIMENSION input_row,
+                   JSAMPARRAY output_buf, int num_rows)
 {
-  jcopy_sample_rows(input_buf[0], (int)input_row, output_buf, 0, num_rows,
-                    cinfo->output_width);
+  jcopy_sample_rows(input_buf[0], (int) input_row, output_buf, 0,
+                    num_rows, cinfo->output_width);
 }


@@ -432,42 +437,43 @@ grayscale_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 */

 METHODDEF(void)
-gray_rgb_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                 JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+gray_rgb_convert (j_decompress_ptr cinfo,
+                  JSAMPIMAGE input_buf, JDIMENSION input_row,
+                  JSAMPARRAY output_buf, int num_rows)
 {
  switch (cinfo->out_color_space) {
-  case JCS_EXT_RGB:
-    gray_extrgb_convert_internal(cinfo, input_buf, input_row, output_buf,
-                                 num_rows);
-    break;
-  case JCS_EXT_RGBX:
-  case JCS_EXT_RGBA:
-    gray_extrgbx_convert_internal(cinfo, input_buf, input_row, output_buf,
-                                  num_rows);
-    break;
-  case JCS_EXT_BGR:
-    gray_extbgr_convert_internal(cinfo, input_buf, input_row, output_buf,
-                                 num_rows);
-    break;
-  case JCS_EXT_BGRX:
-  case JCS_EXT_BGRA:
-    gray_extbgrx_convert_internal(cinfo, input_buf, input_row, output_buf,
-                                  num_rows);
-    break;
-  case JCS_EXT_XBGR:
-  case JCS_EXT_ABGR:
-    gray_extxbgr_convert_internal(cinfo, input_buf, input_row, output_buf,
-                                  num_rows);
-    break;
-  case JCS_EXT_XRGB:
-  case JCS_EXT_ARGB:
-    gray_extxrgb_convert_internal(cinfo, input_buf, input_row, output_buf,
-                                  num_rows);
-    break;
-  default:
-    gray_rgb_convert_internal(cinfo, input_buf, input_row, output_buf,
-                              num_rows);
-    break;
+    case JCS_EXT_RGB:
+      gray_extrgb_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                   num_rows);
+      break;
+    case JCS_EXT_RGBX:
+    case JCS_EXT_RGBA:
+      gray_extrgbx_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                    num_rows);
+      break;
+    case JCS_EXT_BGR:
+      gray_extbgr_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                   num_rows);
+      break;
+    case JCS_EXT_BGRX:
+    case JCS_EXT_BGRA:
+      gray_extbgrx_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                    num_rows);
+      break;
+    case JCS_EXT_XBGR:
+    case JCS_EXT_ABGR:
+      gray_extxbgr_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                    num_rows);
+      break;
+    case JCS_EXT_XRGB:
+    case JCS_EXT_ARGB:
+      gray_extxrgb_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                    num_rows);
+      break;
+    default:
+      gray_rgb_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                num_rows);
+      break;
  }
 }

@@ -477,42 +483,43 @@ gray_rgb_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 */

 METHODDEF(void)
-rgb_rgb_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+rgb_rgb_convert (j_decompress_ptr cinfo,
+                  JSAMPIMAGE input_buf, JDIMENSION input_row,
+                  JSAMPARRAY output_buf, int num_rows)
 {
  switch (cinfo->out_color_space) {
-  case JCS_EXT_RGB:
-    rgb_extrgb_convert_internal(cinfo, input_buf, input_row, output_buf,
-                                num_rows);
-    break;
-  case JCS_EXT_RGBX:
-  case JCS_EXT_RGBA:
-    rgb_extrgbx_convert_internal(cinfo, input_buf, input_row, output_buf,
-                                 num_rows);
-    break;
-  case JCS_EXT_BGR:
-    rgb_extbgr_convert_internal(cinfo, input_buf, input_row, output_buf,
-                                num_rows);
-    break;
-  case JCS_EXT_BGRX:
-  case JCS_EXT_BGRA:
-    rgb_extbgrx_convert_internal(cinfo, input_buf, input_row, output_buf,
-                                 num_rows);
-    break;
-  case JCS_EXT_XBGR:
-  case JCS_EXT_ABGR:
-    rgb_extxbgr_convert_internal(cinfo, input_buf, input_row, output_buf,
-                                 num_rows);
-    break;
-  case JCS_EXT_XRGB:
-  case JCS_EXT_ARGB:
-    rgb_extxrgb_convert_internal(cinfo, input_buf, input_row, output_buf,
-                                 num_rows);
-    break;
-  default:
-    rgb_rgb_convert_internal(cinfo, input_buf, input_row, output_buf,
-                             num_rows);
-    break;
+    case JCS_EXT_RGB:
+      rgb_extrgb_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                  num_rows);
+      break;
+    case JCS_EXT_RGBX:
+    case JCS_EXT_RGBA:
+      rgb_extrgbx_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                   num_rows);
+      break;
+    case JCS_EXT_BGR:
+      rgb_extbgr_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                  num_rows);
+      break;
+    case JCS_EXT_BGRX:
+    case JCS_EXT_BGRA:
+      rgb_extbgrx_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                   num_rows);
+      break;
+    case JCS_EXT_XBGR:
+    case JCS_EXT_ABGR:
+      rgb_extxbgr_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                   num_rows);
+      break;
+    case JCS_EXT_XRGB:
+    case JCS_EXT_ARGB:
+      rgb_extxrgb_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                   num_rows);
+      break;
+    default:
+      rgb_rgb_convert_internal(cinfo, input_buf, input_row, output_buf,
+                               num_rows);
+      break;
  }
 }

@@ -525,10 +532,11 @@ rgb_rgb_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 */

 METHODDEF(void)
-ycck_cmyk_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                  JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+ycck_cmyk_convert (j_decompress_ptr cinfo,
+                   JSAMPIMAGE input_buf, JDIMENSION input_row,
+                   JSAMPARRAY output_buf, int num_rows)
 {
-  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
  register int y, cb, cr;
  register JSAMPROW outptr;
  register JSAMPROW inptr0, inptr1, inptr2, inptr3;
@@ -550,17 +558,17 @@ ycck_cmyk_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
    input_row++;
    outptr = *output_buf++;
    for (col = 0; col < num_cols; col++) {
-      y  = inptr0[col];
-      cb = inptr1[col];
-      cr = inptr2[col];
+      y  = GETJSAMPLE(inptr0[col]);
+      cb = GETJSAMPLE(inptr1[col]);
+      cr = GETJSAMPLE(inptr2[col]);
      /* Range-limiting is essential due to noise introduced by DCT losses. */
      outptr[0] = range_limit[MAXJSAMPLE - (y + Crrtab[cr])];   /* red */
      outptr[1] = range_limit[MAXJSAMPLE - (y +                 /* green */
-                              ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
+                              ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
                                                 SCALEBITS)))];
      outptr[2] = range_limit[MAXJSAMPLE - (y + Cbbtab[cb])];   /* blue */
      /* K passes through unchanged */
-      outptr[3] = inptr3[col];
+      outptr[3] = inptr3[col];  /* don't need GETJSAMPLE here */
      outptr += 4;
    }
  }
@@ -571,15 +579,16 @@ ycck_cmyk_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 * RGB565 conversion
 */

-#define PACK_SHORT_565_LE(r, g, b) \
-  ((((r) << 8) & 0xF800) | (((g) << 3) & 0x7E0) | ((b) >> 3))
-#define PACK_SHORT_565_BE(r, g, b) \
-  (((r) & 0xF8) | ((g) >> 5) | (((g) << 11) & 0xE000) | (((b) << 5) & 0x1F00))
+#define PACK_SHORT_565_LE(r, g, b)   ((((r) << 8) & 0xF800) |  \
+                                      (((g) << 3) & 0x7E0) | ((b) >> 3))
+#define PACK_SHORT_565_BE(r, g, b)   (((r) & 0xF8) | ((g) >> 5) |  \
+                                      (((g) << 11) & 0xE000) |  \
+                                      (((b) << 5) & 0x1F00))

-#define PACK_TWO_PIXELS_LE(l, r)    ((r << 16) | l)
-#define PACK_TWO_PIXELS_BE(l, r)    ((l << 16) | r)
+#define PACK_TWO_PIXELS_LE(l, r)     ((r << 16) | l)
+#define PACK_TWO_PIXELS_BE(l, r)     ((l << 16) | r)

-#define PACK_NEED_ALIGNMENT(ptr)    (((size_t)(ptr)) & 3)
+#define PACK_NEED_ALIGNMENT(ptr)     (((size_t)(ptr)) & 3)

 #define WRITE_TWO_ALIGNED_PIXELS(addr, pixels)  ((*(int *)(addr)) = pixels)

@@ -591,7 +600,7 @@ ycck_cmyk_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 /* Declarations for ordered dithering
 *
 * We use a 4x4 ordered dither array packed into 32 bits.  This array is
- * sufficient for dithering RGB888 to RGB565.
+ * sufficent for dithering RGB888 to RGB565.
 */

 #define DITHER_MASK       0x3
@@ -615,14 +624,14 @@ static INLINE boolean is_big_endian(void)

 /* Include inline routines for RGB565 conversion */

-#define PACK_SHORT_565  PACK_SHORT_565_LE
-#define PACK_TWO_PIXELS  PACK_TWO_PIXELS_LE
-#define ycc_rgb565_convert_internal  ycc_rgb565_convert_le
-#define ycc_rgb565D_convert_internal  ycc_rgb565D_convert_le
-#define rgb_rgb565_convert_internal  rgb_rgb565_convert_le
-#define rgb_rgb565D_convert_internal  rgb_rgb565D_convert_le
-#define gray_rgb565_convert_internal  gray_rgb565_convert_le
-#define gray_rgb565D_convert_internal  gray_rgb565D_convert_le
+#define PACK_SHORT_565 PACK_SHORT_565_LE
+#define PACK_TWO_PIXELS PACK_TWO_PIXELS_LE
+#define ycc_rgb565_convert_internal ycc_rgb565_convert_le
+#define ycc_rgb565D_convert_internal ycc_rgb565D_convert_le
+#define rgb_rgb565_convert_internal rgb_rgb565_convert_le
+#define rgb_rgb565D_convert_internal rgb_rgb565D_convert_le
+#define gray_rgb565_convert_internal gray_rgb565_convert_le
+#define gray_rgb565D_convert_internal gray_rgb565D_convert_le
 #include "jdcol565.c"
 #undef PACK_SHORT_565
 #undef PACK_TWO_PIXELS
@@ -633,14 +642,14 @@ static INLINE boolean is_big_endian(void)
 #undef gray_rgb565_convert_internal
 #undef gray_rgb565D_convert_internal

-#define PACK_SHORT_565  PACK_SHORT_565_BE
-#define PACK_TWO_PIXELS  PACK_TWO_PIXELS_BE
-#define ycc_rgb565_convert_internal  ycc_rgb565_convert_be
-#define ycc_rgb565D_convert_internal  ycc_rgb565D_convert_be
-#define rgb_rgb565_convert_internal  rgb_rgb565_convert_be
-#define rgb_rgb565D_convert_internal  rgb_rgb565D_convert_be
-#define gray_rgb565_convert_internal  gray_rgb565_convert_be
-#define gray_rgb565D_convert_internal  gray_rgb565D_convert_be
+#define PACK_SHORT_565 PACK_SHORT_565_BE
+#define PACK_TWO_PIXELS PACK_TWO_PIXELS_BE
+#define ycc_rgb565_convert_internal ycc_rgb565_convert_be
+#define ycc_rgb565D_convert_internal ycc_rgb565D_convert_be
+#define rgb_rgb565_convert_internal rgb_rgb565_convert_be
+#define rgb_rgb565D_convert_internal rgb_rgb565D_convert_be
+#define gray_rgb565_convert_internal gray_rgb565_convert_be
+#define gray_rgb565D_convert_internal gray_rgb565D_convert_be
 #include "jdcol565.c"
 #undef PACK_SHORT_565
 #undef PACK_TWO_PIXELS
@@ -653,8 +662,9 @@ static INLINE boolean is_big_endian(void)


 METHODDEF(void)
-ycc_rgb565_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                   JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+ycc_rgb565_convert (j_decompress_ptr cinfo,
+                    JSAMPIMAGE input_buf, JDIMENSION input_row,
+                    JSAMPARRAY output_buf, int num_rows)
 {
  if (is_big_endian())
    ycc_rgb565_convert_be(cinfo, input_buf, input_row, output_buf, num_rows);
@@ -664,8 +674,9 @@ ycc_rgb565_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,


 METHODDEF(void)
-ycc_rgb565D_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                    JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+ycc_rgb565D_convert (j_decompress_ptr cinfo,
+                     JSAMPIMAGE input_buf, JDIMENSION input_row,
+                     JSAMPARRAY output_buf, int num_rows)
 {
  if (is_big_endian())
    ycc_rgb565D_convert_be(cinfo, input_buf, input_row, output_buf, num_rows);
@@ -675,8 +686,9 @@ ycc_rgb565D_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,


 METHODDEF(void)
-rgb_rgb565_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                   JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+rgb_rgb565_convert (j_decompress_ptr cinfo,
+                    JSAMPIMAGE input_buf, JDIMENSION input_row,
+                    JSAMPARRAY output_buf, int num_rows)
 {
  if (is_big_endian())
    rgb_rgb565_convert_be(cinfo, input_buf, input_row, output_buf, num_rows);
@@ -686,8 +698,9 @@ rgb_rgb565_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,


 METHODDEF(void)
-rgb_rgb565D_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                    JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+rgb_rgb565D_convert (j_decompress_ptr cinfo,
+                     JSAMPIMAGE input_buf, JDIMENSION input_row,
+                     JSAMPARRAY output_buf, int num_rows)
 {
  if (is_big_endian())
    rgb_rgb565D_convert_be(cinfo, input_buf, input_row, output_buf, num_rows);
@@ -697,8 +710,9 @@ rgb_rgb565D_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,


 METHODDEF(void)
-gray_rgb565_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                    JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+gray_rgb565_convert (j_decompress_ptr cinfo,
+                     JSAMPIMAGE input_buf, JDIMENSION input_row,
+                     JSAMPARRAY output_buf, int num_rows)
 {
  if (is_big_endian())
    gray_rgb565_convert_be(cinfo, input_buf, input_row, output_buf, num_rows);
@@ -708,8 +722,9 @@ gray_rgb565_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,


 METHODDEF(void)
-gray_rgb565D_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                     JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+gray_rgb565D_convert (j_decompress_ptr cinfo,
+                      JSAMPIMAGE input_buf, JDIMENSION input_row,
+                      JSAMPARRAY output_buf, int num_rows)
 {
  if (is_big_endian())
    gray_rgb565D_convert_be(cinfo, input_buf, input_row, output_buf, num_rows);
@@ -723,7 +738,7 @@ gray_rgb565D_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 */

 METHODDEF(void)
-start_pass_dcolor(j_decompress_ptr cinfo)
+start_pass_dcolor (j_decompress_ptr cinfo)
 {
  /* no work needed */
 }
@@ -734,15 +749,15 @@ start_pass_dcolor(j_decompress_ptr cinfo)
 */

 GLOBAL(void)
-jinit_color_deconverter(j_decompress_ptr cinfo)
+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,
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                sizeof(my_color_deconverter));
-  cinfo->cconvert = (struct jpeg_color_deconverter *)cconvert;
+  cinfo->cconvert = (struct jpeg_color_deconverter *) cconvert;
  cconvert->pub.start_pass = start_pass_dcolor;

  /* Make sure num_components agrees with jpeg_color_space */
@@ -828,11 +843,11 @@ jinit_color_deconverter(j_decompress_ptr cinfo)
    cinfo->out_color_components = 3;
    if (cinfo->dither_mode == JDITHER_NONE) {
      if (cinfo->jpeg_color_space == JCS_YCbCr) {
-        if (jsimd_can_ycc_rgb565())
-          cconvert->pub.color_convert = jsimd_ycc_rgb565_convert;
-        else {
-          cconvert->pub.color_convert = ycc_rgb565_convert;
-          build_ycc_rgb_table(cinfo);
+         if (jsimd_can_ycc_rgb565())
+           cconvert->pub.color_convert = jsimd_ycc_rgb565_convert;
+         else {
+           cconvert->pub.color_convert = ycc_rgb565_convert;
+           build_ycc_rgb_table(cinfo);
        }
      } else if (cinfo->jpeg_color_space == JCS_GRAYSCALE) {
        cconvert->pub.color_convert = gray_rgb565_convert;
@@ -36,7 +36,7 @@ typedef int DCTELEM;            /* 16 or 32 bits is fine */
 typedef unsigned int UDCTELEM;
 typedef unsigned long long UDCTELEM2;
 #else
-typedef short DCTELEM;          /* prefer 16 bit with SIMD for parellelism */
+typedef short DCTELEM;  /* prefer 16 bit with SIMD for parellelism */
 typedef unsigned short UDCTELEM;
 typedef unsigned int UDCTELEM2;
 #endif
@@ -63,15 +63,15 @@ typedef unsigned long long UDCTELEM2;
 * Each IDCT routine has its own ideas about the best dct_table element type.
 */

-typedef MULTIPLIER ISLOW_MULT_TYPE;  /* short or int, whichever is faster */
+typedef MULTIPLIER ISLOW_MULT_TYPE; /* short or int, whichever is faster */
 #if BITS_IN_JSAMPLE == 8
-typedef MULTIPLIER IFAST_MULT_TYPE;  /* 16 bits is OK, use short if faster */
-#define IFAST_SCALE_BITS  2          /* fractional bits in scale factors */
+typedef MULTIPLIER IFAST_MULT_TYPE; /* 16 bits is OK, use short if faster */
+#define IFAST_SCALE_BITS  2     /* fractional bits in scale factors */
 #else
-typedef JLONG IFAST_MULT_TYPE;       /* need 32 bits for scaled quantizers */
-#define IFAST_SCALE_BITS  13         /* fractional bits in scale factors */
+typedef JLONG IFAST_MULT_TYPE;  /* need 32 bits for scaled quantizers */
+#define IFAST_SCALE_BITS  13    /* fractional bits in scale factors */
 #endif
-typedef FAST_FLOAT FLOAT_MULT_TYPE;  /* preferred floating type */
+typedef FAST_FLOAT FLOAT_MULT_TYPE; /* preferred floating type */


 /*
@@ -90,64 +90,64 @@ typedef FAST_FLOAT FLOAT_MULT_TYPE;  /* preferred floating type */

 /* Extern declarations for the forward and inverse DCT routines. */

-EXTERN(void) jpeg_fdct_islow(DCTELEM *data);
-EXTERN(void) jpeg_fdct_ifast(DCTELEM *data);
-EXTERN(void) jpeg_fdct_float(FAST_FLOAT *data);
+EXTERN(void) jpeg_fdct_islow (DCTELEM *data);
+EXTERN(void) jpeg_fdct_ifast (DCTELEM *data);
+EXTERN(void) jpeg_fdct_float (FAST_FLOAT *data);

-EXTERN(void) jpeg_idct_islow(j_decompress_ptr cinfo,
-                             jpeg_component_info *compptr, JCOEFPTR coef_block,
-                             JSAMPARRAY output_buf, JDIMENSION output_col);
-EXTERN(void) jpeg_idct_ifast(j_decompress_ptr cinfo,
-                             jpeg_component_info *compptr, JCOEFPTR coef_block,
-                             JSAMPARRAY output_buf, JDIMENSION output_col);
-EXTERN(void) jpeg_idct_float(j_decompress_ptr cinfo,
-                             jpeg_component_info *compptr, JCOEFPTR coef_block,
-                             JSAMPARRAY output_buf, JDIMENSION output_col);
-EXTERN(void) jpeg_idct_7x7(j_decompress_ptr cinfo,
-                           jpeg_component_info *compptr, JCOEFPTR coef_block,
-                           JSAMPARRAY output_buf, JDIMENSION output_col);
-EXTERN(void) jpeg_idct_6x6(j_decompress_ptr cinfo,
-                           jpeg_component_info *compptr, JCOEFPTR coef_block,
-                           JSAMPARRAY output_buf, JDIMENSION output_col);
-EXTERN(void) jpeg_idct_5x5(j_decompress_ptr cinfo,
-                           jpeg_component_info *compptr, JCOEFPTR coef_block,
-                           JSAMPARRAY output_buf, JDIMENSION output_col);
-EXTERN(void) jpeg_idct_4x4(j_decompress_ptr cinfo,
-                           jpeg_component_info *compptr, JCOEFPTR coef_block,
-                           JSAMPARRAY output_buf, JDIMENSION output_col);
-EXTERN(void) jpeg_idct_3x3(j_decompress_ptr cinfo,
-                           jpeg_component_info *compptr, JCOEFPTR coef_block,
-                           JSAMPARRAY output_buf, JDIMENSION output_col);
-EXTERN(void) jpeg_idct_2x2(j_decompress_ptr cinfo,
-                           jpeg_component_info *compptr, JCOEFPTR coef_block,
-                           JSAMPARRAY output_buf, JDIMENSION output_col);
-EXTERN(void) jpeg_idct_1x1(j_decompress_ptr cinfo,
-                           jpeg_component_info *compptr, JCOEFPTR coef_block,
-                           JSAMPARRAY output_buf, JDIMENSION output_col);
-EXTERN(void) jpeg_idct_9x9(j_decompress_ptr cinfo,
-                           jpeg_component_info *compptr, JCOEFPTR coef_block,
-                           JSAMPARRAY output_buf, JDIMENSION output_col);
-EXTERN(void) jpeg_idct_10x10(j_decompress_ptr cinfo,
-                             jpeg_component_info *compptr, JCOEFPTR coef_block,
-                             JSAMPARRAY output_buf, JDIMENSION output_col);
-EXTERN(void) jpeg_idct_11x11(j_decompress_ptr cinfo,
-                             jpeg_component_info *compptr, JCOEFPTR coef_block,
-                             JSAMPARRAY output_buf, JDIMENSION output_col);
-EXTERN(void) jpeg_idct_12x12(j_decompress_ptr cinfo,
-                             jpeg_component_info *compptr, JCOEFPTR coef_block,
-                             JSAMPARRAY output_buf, JDIMENSION output_col);
-EXTERN(void) jpeg_idct_13x13(j_decompress_ptr cinfo,
-                             jpeg_component_info *compptr, JCOEFPTR coef_block,
-                             JSAMPARRAY output_buf, JDIMENSION output_col);
-EXTERN(void) jpeg_idct_14x14(j_decompress_ptr cinfo,
-                             jpeg_component_info *compptr, JCOEFPTR coef_block,
-                             JSAMPARRAY output_buf, JDIMENSION output_col);
-EXTERN(void) jpeg_idct_15x15(j_decompress_ptr cinfo,
-                             jpeg_component_info *compptr, JCOEFPTR coef_block,
-                             JSAMPARRAY output_buf, JDIMENSION output_col);
-EXTERN(void) jpeg_idct_16x16(j_decompress_ptr cinfo,
-                             jpeg_component_info *compptr, JCOEFPTR coef_block,
-                             JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_islow
+        (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+         JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_ifast
+        (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+         JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_float
+        (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+         JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_7x7
+        (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+         JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_6x6
+        (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+         JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_5x5
+        (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+         JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_4x4
+        (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+         JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_3x3
+        (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+         JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_2x2
+        (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+         JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_1x1
+        (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+         JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_9x9
+        (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+         JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_10x10
+        (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+         JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_11x11
+        (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+         JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_12x12
+        (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+         JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_13x13
+        (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+         JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_14x14
+        (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+         JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_15x15
+        (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+         JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_16x16
+        (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+         JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);


 /*
@@ -160,22 +160,22 @@ EXTERN(void) jpeg_idct_16x16(j_decompress_ptr cinfo,
 * and may differ from one module to the next.
 */

-#define ONE          ((JLONG)1)
-#define CONST_SCALE  (ONE << CONST_BITS)
+#define ONE     ((JLONG) 1)
+#define CONST_SCALE (ONE << CONST_BITS)

 /* Convert a positive real constant to an integer scaled by CONST_SCALE.
 * Caution: some C compilers fail to reduce "FIX(constant)" at compile time,
 * thus causing a lot of useless floating-point operations at run time.
 */

-#define FIX(x)  ((JLONG)((x) * CONST_SCALE + 0.5))
+#define FIX(x)  ((JLONG) ((x) * CONST_SCALE + 0.5))

 /* Descale and correctly round a JLONG 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)
+#define DESCALE(x,n)  RIGHT_SHIFT((x) + (ONE << ((n)-1)), n)

 /* Multiply a JLONG variable by a JLONG constant to yield a JLONG result.
 * This macro is used only when the two inputs will actually be no more than
@@ -187,22 +187,22 @@ EXTERN(void) jpeg_idct_16x16(j_decompress_ptr cinfo,
 */

 #ifdef SHORTxSHORT_32           /* may work if 'int' is 32 bits */
-#define MULTIPLY16C16(var, const)  (((INT16)(var)) * ((INT16)(const)))
+#define MULTIPLY16C16(var,const)  (((INT16) (var)) * ((INT16) (const)))
 #endif
 #ifdef SHORTxLCONST_32          /* known to work with Microsoft C 6.0 */
-#define MULTIPLY16C16(var, const)  (((INT16)(var)) * ((JLONG)(const)))
+#define MULTIPLY16C16(var,const)  (((INT16) (var)) * ((JLONG) (const)))
 #endif

 #ifndef MULTIPLY16C16           /* default definition */
-#define MULTIPLY16C16(var, const)  ((var) * (const))
+#define MULTIPLY16C16(var,const)  ((var) * (const))
 #endif

 /* Same except both inputs are variables. */

 #ifdef SHORTxSHORT_32           /* may work if 'int' is 32 bits */
-#define MULTIPLY16V16(var1, var2)  (((INT16)(var1)) * ((INT16)(var2)))
+#define MULTIPLY16V16(var1,var2)  (((INT16) (var1)) * ((INT16) (var2)))
 #endif

 #ifndef MULTIPLY16V16           /* default definition */
-#define MULTIPLY16V16(var1, var2)  ((var1) * (var2))
+#define MULTIPLY16V16(var1,var2)  ((var1) * (var2))
 #endif
@@ -94,9 +94,9 @@ typedef union {
 */

 METHODDEF(void)
-start_pass(j_decompress_ptr cinfo)
+start_pass (j_decompress_ptr cinfo)
 {
-  my_idct_ptr idct = (my_idct_ptr)cinfo->idct;
+  my_idct_ptr idct = (my_idct_ptr) cinfo->idct;
  int ci, i;
  jpeg_component_info *compptr;
  int method = 0;
@@ -233,7 +233,7 @@ start_pass(j_decompress_ptr cinfo)
     * multiplier table all-zero; we'll be reading zeroes from the
     * coefficient controller's buffer anyway.
     */
-    if (!compptr->component_needed || idct->cur_method[ci] == method)
+    if (! compptr->component_needed || idct->cur_method[ci] == method)
      continue;
    qtbl = compptr->quant_table;
    if (qtbl == NULL)           /* happens if no data yet for component */
@@ -246,9 +246,9 @@ start_pass(j_decompress_ptr cinfo)
        /* For LL&M IDCT method, multipliers are equal to raw quantization
         * coefficients, but are stored as ints to ensure access efficiency.
         */
-        ISLOW_MULT_TYPE *ismtbl = (ISLOW_MULT_TYPE *)compptr->dct_table;
+        ISLOW_MULT_TYPE *ismtbl = (ISLOW_MULT_TYPE *) compptr->dct_table;
        for (i = 0; i < DCTSIZE2; i++) {
-          ismtbl[i] = (ISLOW_MULT_TYPE)qtbl->quantval[i];
+          ismtbl[i] = (ISLOW_MULT_TYPE) qtbl->quantval[i];
        }
      }
      break;
@@ -263,8 +263,8 @@ start_pass(j_decompress_ptr cinfo)
         * For integer operation, the multiplier table is to be scaled by
         * IFAST_SCALE_BITS.
         */
-        IFAST_MULT_TYPE *ifmtbl = (IFAST_MULT_TYPE *)compptr->dct_table;
-#define CONST_BITS  14
+        IFAST_MULT_TYPE *ifmtbl = (IFAST_MULT_TYPE *) compptr->dct_table;
+#define CONST_BITS 14
        static const INT16 aanscales[DCTSIZE2] = {
          /* precomputed values scaled up by 14 bits */
          16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
@@ -280,9 +280,9 @@ start_pass(j_decompress_ptr cinfo)

        for (i = 0; i < DCTSIZE2; i++) {
          ifmtbl[i] = (IFAST_MULT_TYPE)
-            DESCALE(MULTIPLY16V16((JLONG)qtbl->quantval[i],
-                                  (JLONG)aanscales[i]),
-                    CONST_BITS - IFAST_SCALE_BITS);
+            DESCALE(MULTIPLY16V16((JLONG) qtbl->quantval[i],
+                                  (JLONG) aanscales[i]),
+                    CONST_BITS-IFAST_SCALE_BITS);
        }
      }
      break;
@@ -295,7 +295,7 @@ start_pass(j_decompress_ptr cinfo)
         *   scalefactor[0] = 1
         *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
         */
-        FLOAT_MULT_TYPE *fmtbl = (FLOAT_MULT_TYPE *)compptr->dct_table;
+        FLOAT_MULT_TYPE *fmtbl = (FLOAT_MULT_TYPE *) compptr->dct_table;
        int row, col;
        static const double aanscalefactor[DCTSIZE] = {
          1.0, 1.387039845, 1.306562965, 1.175875602,
@@ -306,7 +306,7 @@ start_pass(j_decompress_ptr cinfo)
        for (row = 0; row < DCTSIZE; row++) {
          for (col = 0; col < DCTSIZE; col++) {
            fmtbl[i] = (FLOAT_MULT_TYPE)
-              ((double)qtbl->quantval[i] *
+              ((double) qtbl->quantval[i] *
               aanscalefactor[row] * aanscalefactor[col]);
            i++;
          }
@@ -327,23 +327,23 @@ start_pass(j_decompress_ptr cinfo)
 */

 GLOBAL(void)
-jinit_inverse_dct(j_decompress_ptr cinfo)
+jinit_inverse_dct (j_decompress_ptr cinfo)
 {
  my_idct_ptr idct;
  int ci;
  jpeg_component_info *compptr;

  idct = (my_idct_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                sizeof(my_idct_controller));
-  cinfo->idct = (struct jpeg_inverse_dct *)idct;
+  cinfo->idct = (struct jpeg_inverse_dct *) idct;
  idct->pub.start_pass = start_pass;

  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
       ci++, compptr++) {
    /* Allocate and pre-zero a multiplier table for each component */
    compptr->dct_table =
-      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                  sizeof(multiplier_table));
    MEMZERO(compptr->dct_table, sizeof(multiplier_table));
    /* Mark multiplier table not yet set up for any method */
@@ -4,8 +4,7 @@
 * This file was part of the Independent JPEG Group's software:
 * Copyright (C) 1991-1997, Thomas G. Lane.
 * libjpeg-turbo Modifications:
- * Copyright (C) 2009-2011, 2016, 2018-2019, D. R. Commander.
- * Copyright (C) 2018, Matthias Räncker.
+ * Copyright (C) 2009-2011, 2016, D. R. Commander.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
 *
@@ -16,9 +15,6 @@
 * up to the start of the current MCU.  To do this, we copy state variables
 * into local working storage, and update them back to the permanent
 * storage only upon successful completion of an MCU.
- *
- * NOTE: All referenced figures are from
- * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994.
 */

 #define JPEG_INTERNALS
@@ -40,6 +36,24 @@ typedef struct {
  int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
 } savable_state;

+/* This macro is to work around compilers with missing or broken
+ * structure assignment.  You'll need to fix this code if you have
+ * such a compiler and you change MAX_COMPS_IN_SCAN.
+ */
+
+#ifndef NO_STRUCT_ASSIGN
+#define ASSIGN_STATE(dest,src)  ((dest) = (src))
+#else
+#if MAX_COMPS_IN_SCAN == 4
+#define ASSIGN_STATE(dest,src)  \
+        ((dest).last_dc_val[0] = (src).last_dc_val[0], \
+         (dest).last_dc_val[1] = (src).last_dc_val[1], \
+         (dest).last_dc_val[2] = (src).last_dc_val[2], \
+         (dest).last_dc_val[3] = (src).last_dc_val[3])
+#endif
+#endif
+
+
 typedef struct {
  struct jpeg_entropy_decoder pub; /* public fields */

@@ -74,9 +88,9 @@ typedef huff_entropy_decoder *huff_entropy_ptr;
 */

 METHODDEF(void)
-start_pass_huff_decoder(j_decompress_ptr cinfo)
+start_pass_huff_decoder (j_decompress_ptr cinfo)
 {
-  huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
  int ci, blkn, dctbl, actbl;
  d_derived_tbl **pdtbl;
  jpeg_component_info *compptr;
@@ -85,7 +99,7 @@ start_pass_huff_decoder(j_decompress_ptr cinfo)
   * This ought to be an error condition, but we make it a warning because
   * there are some baseline files out there with all zeroes in these bytes.
   */
-  if (cinfo->Ss != 0 || cinfo->Se != DCTSIZE2 - 1 ||
+  if (cinfo->Ss != 0 || cinfo->Se != DCTSIZE2-1 ||
      cinfo->Ah != 0 || cinfo->Al != 0)
    WARNMS(cinfo, JWRN_NOT_SEQUENTIAL);

@@ -138,8 +152,8 @@ start_pass_huff_decoder(j_decompress_ptr cinfo)
 */

 GLOBAL(void)
-jpeg_make_d_derived_tbl(j_decompress_ptr cinfo, boolean isDC, int tblno,
-                        d_derived_tbl **pdtbl)
+jpeg_make_d_derived_tbl (j_decompress_ptr cinfo, boolean isDC, int tblno,
+                         d_derived_tbl **pdtbl)
 {
  JHUFF_TBL *htbl;
  d_derived_tbl *dtbl;
@@ -164,7 +178,7 @@ jpeg_make_d_derived_tbl(j_decompress_ptr cinfo, boolean isDC, int 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,
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                  sizeof(d_derived_tbl));
  dtbl = *pdtbl;
  dtbl->pub = htbl;             /* fill in back link */
@@ -173,11 +187,11 @@ jpeg_make_d_derived_tbl(j_decompress_ptr cinfo, boolean isDC, int tblno,

  p = 0;
  for (l = 1; l <= 16; l++) {
-    i = (int)htbl->bits[l];
+    i = (int) htbl->bits[l];
    if (i < 0 || p + i > 256)   /* protect against table overrun */
      ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
    while (i--)
-      huffsize[p++] = (char)l;
+      huffsize[p++] = (char) l;
  }
  huffsize[p] = 0;
  numsymbols = p;
@@ -189,14 +203,14 @@ jpeg_make_d_derived_tbl(j_decompress_ptr cinfo, boolean isDC, int tblno,
  si = huffsize[0];
  p = 0;
  while (huffsize[p]) {
-    while (((int)huffsize[p]) == si) {
+    while (((int) huffsize[p]) == si) {
      huffcode[p++] = code;
      code++;
    }
    /* code is now 1 more than the last code used for codelength si; but
     * it must still fit in si bits, since no code is allowed to be all ones.
     */
-    if (((JLONG)code) >= (((JLONG)1) << si))
+    if (((JLONG) code) >= (((JLONG) 1) << si))
      ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
    code <<= 1;
    si++;
@@ -210,9 +224,9 @@ jpeg_make_d_derived_tbl(j_decompress_ptr cinfo, boolean isDC, int tblno,
      /* valoffset[l] = huffval[] index of 1st symbol of code length l,
       * minus the minimum code of length l
       */
-      dtbl->valoffset[l] = (JLONG)p - (JLONG)huffcode[p];
+      dtbl->valoffset[l] = (JLONG) p - (JLONG) huffcode[p];
      p += htbl->bits[l];
-      dtbl->maxcode[l] = huffcode[p - 1]; /* maximum code of length l */
+      dtbl->maxcode[l] = huffcode[p-1]; /* maximum code of length l */
    } else {
      dtbl->maxcode[l] = -1;    /* -1 if no codes of this length */
    }
@@ -227,16 +241,16 @@ jpeg_make_d_derived_tbl(j_decompress_ptr cinfo, boolean isDC, int tblno,
   * with that code.
   */

-  for (i = 0; i < (1 << HUFF_LOOKAHEAD); i++)
-    dtbl->lookup[i] = (HUFF_LOOKAHEAD + 1) << HUFF_LOOKAHEAD;
+   for (i = 0; i < (1 << HUFF_LOOKAHEAD); i++)
+     dtbl->lookup[i] = (HUFF_LOOKAHEAD + 1) << HUFF_LOOKAHEAD;

  p = 0;
  for (l = 1; l <= HUFF_LOOKAHEAD; l++) {
-    for (i = 1; i <= (int)htbl->bits[l]; i++, p++) {
+    for (i = 1; i <= (int) htbl->bits[l]; i++, p++) {
      /* l = current code's length, p = its index in huffcode[] & huffval[]. */
      /* Generate left-justified code followed by all possible bit sequences */
-      lookbits = huffcode[p] << (HUFF_LOOKAHEAD - l);
-      for (ctr = 1 << (HUFF_LOOKAHEAD - l); ctr > 0; ctr--) {
+      lookbits = huffcode[p] << (HUFF_LOOKAHEAD-l);
+      for (ctr = 1 << (HUFF_LOOKAHEAD-l); ctr > 0; ctr--) {
        dtbl->lookup[lookbits] = (l << HUFF_LOOKAHEAD) | htbl->huffval[p];
        lookbits++;
      }
@@ -277,14 +291,14 @@ jpeg_make_d_derived_tbl(j_decompress_ptr cinfo, boolean isDC, int tblno,
 #ifdef SLOW_SHIFT_32
 #define MIN_GET_BITS  15        /* minimum allowable value */
 #else
-#define MIN_GET_BITS  (BIT_BUF_SIZE - 7)
+#define MIN_GET_BITS  (BIT_BUF_SIZE-7)
 #endif


 GLOBAL(boolean)
-jpeg_fill_bit_buffer(bitread_working_state *state,
-                     register bit_buf_type get_buffer, register int bits_left,
-                     int nbits)
+jpeg_fill_bit_buffer (bitread_working_state *state,
+                      register bit_buf_type get_buffer, register int bits_left,
+                      int nbits)
 /* Load up the bit buffer to a depth of at least nbits */
 {
  /* Copy heavily used state fields into locals (hopefully registers) */
@@ -302,13 +316,13 @@ jpeg_fill_bit_buffer(bitread_working_state *state,

      /* Attempt to read a byte */
      if (bytes_in_buffer == 0) {
-        if (!(*cinfo->src->fill_input_buffer) (cinfo))
+        if (! (*cinfo->src->fill_input_buffer) (cinfo))
          return FALSE;
        next_input_byte = cinfo->src->next_input_byte;
        bytes_in_buffer = cinfo->src->bytes_in_buffer;
      }
      bytes_in_buffer--;
-      c = *next_input_byte++;
+      c = GETJOCTET(*next_input_byte++);

      /* If it's 0xFF, check and discard stuffed zero byte */
      if (c == 0xFF) {
@@ -319,13 +333,13 @@ jpeg_fill_bit_buffer(bitread_working_state *state,
         */
        do {
          if (bytes_in_buffer == 0) {
-            if (!(*cinfo->src->fill_input_buffer) (cinfo))
+            if (! (*cinfo->src->fill_input_buffer) (cinfo))
              return FALSE;
            next_input_byte = cinfo->src->next_input_byte;
            bytes_in_buffer = cinfo->src->bytes_in_buffer;
          }
          bytes_in_buffer--;
-          c = *next_input_byte++;
+          c = GETJOCTET(*next_input_byte++);
        } while (c == 0xFF);

        if (c == 0) {
@@ -351,7 +365,7 @@ jpeg_fill_bit_buffer(bitread_working_state *state,
      bits_left += 8;
    } /* end while */
  } else {
-no_more_bytes:
+  no_more_bytes:
    /* We get here if we've read the marker that terminates the compressed
     * data segment.  There should be enough bits in the buffer register
     * to satisfy the request; if so, no problem.
@@ -362,7 +376,7 @@ no_more_bytes:
       * We use a nonvolatile flag to ensure that only one warning message
       * appears per data segment.
       */
-      if (!cinfo->entropy->insufficient_data) {
+      if (! cinfo->entropy->insufficient_data) {
        WARNMS(cinfo, JWRN_HIT_MARKER);
        cinfo->entropy->insufficient_data = TRUE;
      }
@@ -386,10 +400,11 @@ no_more_bytes:
   handle markers.  We have to hand off any blocks with markers to the
   slower routines. */

-#define GET_BYTE { \
+#define GET_BYTE \
+{ \
  register int c0, c1; \
-  c0 = *buffer++; \
-  c1 = *buffer; \
+  c0 = GETJOCTET(*buffer++); \
+  c1 = GETJOCTET(*buffer); \
  /* Pre-execute most common case */ \
  get_buffer = (get_buffer << 8) | c0; \
  bits_left += 8; \
@@ -406,7 +421,7 @@ no_more_bytes:
  } \
 }

-#if SIZEOF_SIZE_T == 8 || defined(_WIN64) || (defined(__x86_64__) && defined(__ILP32__))
+#if SIZEOF_SIZE_T==8 || defined(_WIN64)

 /* Pre-fetch 48 bytes, because the holding register is 64-bit */
 #define FILL_BIT_BUFFER_FAST \
@@ -431,9 +446,9 @@ no_more_bytes:
 */

 GLOBAL(int)
-jpeg_huff_decode(bitread_working_state *state,
-                 register bit_buf_type get_buffer, register int bits_left,
-                 d_derived_tbl *htbl, int min_bits)
+jpeg_huff_decode (bitread_working_state *state,
+                  register bit_buf_type get_buffer, register int bits_left,
+                  d_derived_tbl *htbl, int min_bits)
 {
  register int l = min_bits;
  register JLONG code;
@@ -445,7 +460,7 @@ jpeg_huff_decode(bitread_working_state *state,
  code = GET_BITS(l);

  /* Collect the rest of the Huffman code one bit at a time. */
-  /* This is per Figure F.16. */
+  /* This is per Figure F.16 in the JPEG spec. */

  while (code > htbl->maxcode[l]) {
    code <<= 1;
@@ -465,7 +480,7 @@ jpeg_huff_decode(bitread_working_state *state,
    return 0;                   /* fake a zero as the safest result */
  }

-  return htbl->pub->huffval[(int)(code + htbl->valoffset[l])];
+  return htbl->pub->huffval[ (int) (code + htbl->valoffset[l]) ];
 }


@@ -477,26 +492,22 @@ jpeg_huff_decode(bitread_working_state *state,
 #define AVOID_TABLES
 #ifdef AVOID_TABLES

-#define NEG_1  ((unsigned int)-1)
-#define HUFF_EXTEND(x, s) \
-  ((x) + ((((x) - (1 << ((s) - 1))) >> 31) & (((NEG_1) << (s)) + 1)))
+#define NEG_1 ((unsigned int)-1)
+#define HUFF_EXTEND(x,s)  ((x) + ((((x) - (1<<((s)-1))) >> 31) & (((NEG_1)<<(s)) + 1)))

 #else

-#define HUFF_EXTEND(x, s) \
-  ((x) < extend_test[s] ? (x) + extend_offset[s] : (x))
+#define HUFF_EXTEND(x,s)  ((x) < extend_test[s] ? (x) + extend_offset[s] : (x))

-static const int extend_test[16] = {   /* entry n is 2**(n-1) */
-  0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
-  0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000
-};
+static const int extend_test[16] =   /* entry n is 2**(n-1) */
+  { 0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
+    0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000 };

-static const int extend_offset[16] = { /* entry n is (-1 << n) + 1 */
-  0, ((-1) << 1) + 1, ((-1) << 2) + 1, ((-1) << 3) + 1, ((-1) << 4) + 1,
-  ((-1) << 5) + 1, ((-1) << 6) + 1, ((-1) << 7) + 1, ((-1) << 8) + 1,
-  ((-1) << 9) + 1, ((-1) << 10) + 1, ((-1) << 11) + 1, ((-1) << 12) + 1,
-  ((-1) << 13) + 1, ((-1) << 14) + 1, ((-1) << 15) + 1
-};
+static const int extend_offset[16] = /* entry n is (-1 << n) + 1 */
+  { 0, ((-1)<<1) + 1, ((-1)<<2) + 1, ((-1)<<3) + 1, ((-1)<<4) + 1,
+    ((-1)<<5) + 1, ((-1)<<6) + 1, ((-1)<<7) + 1, ((-1)<<8) + 1,
+    ((-1)<<9) + 1, ((-1)<<10) + 1, ((-1)<<11) + 1, ((-1)<<12) + 1,
+    ((-1)<<13) + 1, ((-1)<<14) + 1, ((-1)<<15) + 1 };

 #endif /* AVOID_TABLES */

@@ -507,9 +518,9 @@ static const int extend_offset[16] = { /* entry n is (-1 << n) + 1 */
 */

 LOCAL(boolean)
-process_restart(j_decompress_ptr cinfo)
+process_restart (j_decompress_ptr cinfo)
 {
-  huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
  int ci;

  /* Throw away any unused bits remaining in bit buffer; */
@@ -518,7 +529,7 @@ process_restart(j_decompress_ptr cinfo)
  entropy->bitstate.bits_left = 0;

  /* Advance past the RSTn marker */
-  if (!(*cinfo->marker->read_restart_marker) (cinfo))
+  if (! (*cinfo->marker->read_restart_marker) (cinfo))
    return FALSE;

  /* Re-initialize DC predictions to 0 */
@@ -540,24 +551,18 @@ process_restart(j_decompress_ptr cinfo)
 }


-#if defined(__has_feature)
-#if __has_feature(undefined_behavior_sanitizer)
-__attribute__((no_sanitize("signed-integer-overflow"),
-               no_sanitize("unsigned-integer-overflow")))
-#endif
-#endif
 LOCAL(boolean)
-decode_mcu_slow(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+decode_mcu_slow (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 {
-  huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
  BITREAD_STATE_VARS;
  int blkn;
  savable_state state;
  /* Outer loop handles each block in the MCU */

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

  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
    JBLOCKROW block = MCU_data ? MCU_data[blkn] : NULL;
@@ -578,19 +583,11 @@ decode_mcu_slow(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
    if (entropy->dc_needed[blkn]) {
      /* Convert DC difference to actual value, update last_dc_val */
      int ci = cinfo->MCU_membership[blkn];
-      /* Certain malformed JPEG images produce repeated DC coefficient
-       * differences of 2047 or -2047, which causes state.last_dc_val[ci] to
-       * grow until it overflows or underflows a 32-bit signed integer.  This
-       * behavior is, to the best of our understanding, innocuous, and it is
-       * unclear how to work around it without potentially affecting
-       * performance.  Thus, we (hopefully temporarily) suppress UBSan integer
-       * overflow errors for this function and decode_mcu_fast().
-       */
      s += state.last_dc_val[ci];
      state.last_dc_val[ci] = s;
      if (block) {
        /* Output the DC coefficient (assumes jpeg_natural_order[0] = 0) */
-        (*block)[0] = (JCOEF)s;
+        (*block)[0] = (JCOEF) s;
      }
    }

@@ -613,7 +610,7 @@ decode_mcu_slow(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
           * Note: the extra entries in jpeg_natural_order[] will save us
           * if k >= DCTSIZE2, which could happen if the data is corrupted.
           */
-          (*block)[jpeg_natural_order[k]] = (JCOEF)s;
+          (*block)[jpeg_natural_order[k]] = (JCOEF) s;
        } else {
          if (r != 15)
            break;
@@ -645,22 +642,16 @@ decode_mcu_slow(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
  }

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


-#if defined(__has_feature)
-#if __has_feature(undefined_behavior_sanitizer)
-__attribute__((no_sanitize("signed-integer-overflow"),
-               no_sanitize("unsigned-integer-overflow")))
-#endif
-#endif
 LOCAL(boolean)
-decode_mcu_fast(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+decode_mcu_fast (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 {
-  huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
  BITREAD_STATE_VARS;
  JOCTET *buffer;
  int blkn;
@@ -668,9 +659,9 @@ decode_mcu_fast(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
  /* Outer loop handles each block in the MCU */

  /* Load up working state */
-  BITREAD_LOAD_STATE(cinfo, entropy->bitstate);
-  buffer = (JOCTET *)br_state.next_input_byte;
-  state = entropy->saved;
+  BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
+  buffer = (JOCTET *) br_state.next_input_byte;
+  ASSIGN_STATE(state, entropy->saved);

  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
    JBLOCKROW block = MCU_data ? MCU_data[blkn] : NULL;
@@ -687,13 +678,10 @@ decode_mcu_fast(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)

    if (entropy->dc_needed[blkn]) {
      int ci = cinfo->MCU_membership[blkn];
-      /* Refer to the comment in decode_mcu_slow() regarding the supression of
-       * a UBSan integer overflow error in this line of code.
-       */
      s += state.last_dc_val[ci];
      state.last_dc_val[ci] = s;
      if (block)
-        (*block)[0] = (JCOEF)s;
+        (*block)[0] = (JCOEF) s;
    }

    if (entropy->ac_needed[blkn] && block) {
@@ -708,7 +696,7 @@ decode_mcu_fast(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
          FILL_BIT_BUFFER_FAST
          r = GET_BITS(s);
          s = HUFF_EXTEND(r, s);
-          (*block)[jpeg_natural_order[k]] = (JCOEF)s;
+          (*block)[jpeg_natural_order[k]] = (JCOEF) s;
        } else {
          if (r != 15) break;
          k += 15;
@@ -741,8 +729,8 @@ decode_mcu_fast(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)

  br_state.bytes_in_buffer -= (buffer - br_state.next_input_byte);
  br_state.next_input_byte = buffer;
-  BITREAD_SAVE_STATE(cinfo, entropy->bitstate);
-  entropy->saved = state;
+  BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
+  ASSIGN_STATE(entropy->saved, state);
  return TRUE;
 }

@@ -762,43 +750,43 @@ decode_mcu_fast(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 * this module, since we'll just re-assign them on the next call.)
 */

-#define BUFSIZE  (DCTSIZE2 * 8)
+#define BUFSIZE (DCTSIZE2 * 8)

 METHODDEF(boolean)
-decode_mcu(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+decode_mcu (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 {
-  huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
  int usefast = 1;

  /* Process restart marker if needed; may have to suspend */
  if (cinfo->restart_interval) {
    if (entropy->restarts_to_go == 0)
-      if (!process_restart(cinfo))
+      if (! process_restart(cinfo))
        return FALSE;
    usefast = 0;
  }

-  if (cinfo->src->bytes_in_buffer < BUFSIZE * (size_t)cinfo->blocks_in_MCU ||
-      cinfo->unread_marker != 0)
+  if (cinfo->src->bytes_in_buffer < BUFSIZE * (size_t)cinfo->blocks_in_MCU
+    || cinfo->unread_marker != 0)
    usefast = 0;

  /* If we've run out of data, just leave the MCU set to zeroes.
   * This way, we return uniform gray for the remainder of the segment.
   */
-  if (!entropy->pub.insufficient_data) {
+  if (! entropy->pub.insufficient_data) {

    if (usefast) {
      if (!decode_mcu_fast(cinfo, MCU_data)) goto use_slow;
-    } else {
-use_slow:
+    }
+    else {
+      use_slow:
      if (!decode_mcu_slow(cinfo, MCU_data)) return FALSE;
    }

  }

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

  return TRUE;
 }
@@ -809,7 +797,7 @@ use_slow:
 */

 GLOBAL(void)
-jinit_huff_decoder(j_decompress_ptr cinfo)
+jinit_huff_decoder (j_decompress_ptr cinfo)
 {
  huff_entropy_ptr entropy;
  int i;
@@ -818,12 +806,12 @@ jinit_huff_decoder(j_decompress_ptr cinfo)
     are the default tables.  Thus, if the tables are not set by the time
     the Huffman decoder is initialized (usually within the body of
     jpeg_start_decompress()), we set them to default values. */
-  std_huff_tables((j_common_ptr)cinfo);
+  std_huff_tables((j_common_ptr) cinfo);

  entropy = (huff_entropy_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                sizeof(huff_entropy_decoder));
-  cinfo->entropy = (struct jpeg_entropy_decoder *)entropy;
+  cinfo->entropy = (struct jpeg_entropy_decoder *) entropy;
  entropy->pub.start_pass = start_pass_huff_decoder;
  entropy->pub.decode_mcu = decode_mcu;

@@ -4,8 +4,7 @@
 * This file was part of the Independent JPEG Group's software:
 * Copyright (C) 1991-1997, Thomas G. Lane.
 * libjpeg-turbo Modifications:
- * Copyright (C) 2010-2011, 2015-2016, 2021, D. R. Commander.
- * Copyright (C) 2018, Matthias Räncker.
+ * Copyright (C) 2010-2011, 2015-2016, D. R. Commander.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
 *
@@ -44,12 +43,13 @@ typedef struct {
   * if too long.  The next 8 bits of each entry contain the
   * symbol.
   */
-  int lookup[1 << HUFF_LOOKAHEAD];
+  int lookup[1<<HUFF_LOOKAHEAD];
 } d_derived_tbl;

 /* Expand a Huffman table definition into the derived format */
-EXTERN(void) jpeg_make_d_derived_tbl(j_decompress_ptr cinfo, boolean isDC,
-                                     int tblno, d_derived_tbl **pdtbl);
+EXTERN(void) jpeg_make_d_derived_tbl
+        (j_decompress_ptr cinfo, boolean isDC, int tblno,
+         d_derived_tbl ** pdtbl);


 /*
@@ -74,16 +74,11 @@ EXTERN(void) jpeg_make_d_derived_tbl(j_decompress_ptr cinfo, boolean isDC,
 #error Cannot determine word size
 #endif

-#if SIZEOF_SIZE_T == 8 || defined(_WIN64)
+#if SIZEOF_SIZE_T==8 || defined(_WIN64)

 typedef size_t bit_buf_type;            /* type of bit-extraction buffer */
 #define BIT_BUF_SIZE  64                /* size of buffer in bits */

-#elif defined(__x86_64__) && defined(__ILP32__)
-
-typedef unsigned long long bit_buf_type; /* type of bit-extraction buffer */
-#define BIT_BUF_SIZE  64                 /* size of buffer in bits */
-
 #else

 typedef unsigned long bit_buf_type;     /* type of bit-extraction buffer */
@@ -118,23 +113,23 @@ typedef struct {                /* Bitreading working state within an MCU */
 } bitread_working_state;

 /* Macros to declare and load/save bitread local variables. */
-#define BITREAD_STATE_VARS \
-  register bit_buf_type get_buffer; \
-  register int bits_left; \
-  bitread_working_state br_state
+#define BITREAD_STATE_VARS  \
+        register bit_buf_type get_buffer;  \
+        register int bits_left;  \
+        bitread_working_state br_state

-#define BITREAD_LOAD_STATE(cinfop, permstate) \
-  br_state.cinfo = cinfop; \
-  br_state.next_input_byte = cinfop->src->next_input_byte; \
-  br_state.bytes_in_buffer = cinfop->src->bytes_in_buffer; \
-  get_buffer = permstate.get_buffer; \
-  bits_left = permstate.bits_left;
+#define BITREAD_LOAD_STATE(cinfop,permstate)  \
+        br_state.cinfo = cinfop; \
+        br_state.next_input_byte = cinfop->src->next_input_byte; \
+        br_state.bytes_in_buffer = cinfop->src->bytes_in_buffer; \
+        get_buffer = permstate.get_buffer; \
+        bits_left = permstate.bits_left;

-#define BITREAD_SAVE_STATE(cinfop, permstate) \
-  cinfop->src->next_input_byte = br_state.next_input_byte; \
-  cinfop->src->bytes_in_buffer = br_state.bytes_in_buffer; \
-  permstate.get_buffer = get_buffer; \
-  permstate.bits_left = bits_left
+#define BITREAD_SAVE_STATE(cinfop,permstate)  \
+        cinfop->src->next_input_byte = br_state.next_input_byte; \
+        cinfop->src->bytes_in_buffer = br_state.bytes_in_buffer; \
+        permstate.get_buffer = get_buffer; \
+        permstate.bits_left = bits_left

 /*
 * These macros provide the in-line portion of bit fetching.
@@ -142,7 +137,7 @@ typedef struct {                /* Bitreading working state within an MCU */
 * before using GET_BITS, PEEK_BITS, or DROP_BITS.
 * The variables get_buffer and bits_left are assumed to be locals,
 * but the state struct might not be (jpeg_huff_decode needs this).
- *      CHECK_BIT_BUFFER(state, n, action);
+ *      CHECK_BIT_BUFFER(state,n,action);
 *              Ensure there are N bits in get_buffer; if suspend, take action.
 *      val = GET_BITS(n);
 *              Fetch next N bits.
@@ -154,27 +149,25 @@ typedef struct {                /* Bitreading working state within an MCU */
 * is evaluated multiple times.
 */

-#define CHECK_BIT_BUFFER(state, nbits, action) { \
-  if (bits_left < (nbits)) { \
-    if (!jpeg_fill_bit_buffer(&(state), get_buffer, bits_left, nbits)) \
-      { action; } \
-    get_buffer = (state).get_buffer;  bits_left = (state).bits_left; \
-  } \
-}
+#define CHECK_BIT_BUFFER(state,nbits,action) \
+        { if (bits_left < (nbits)) {  \
+            if (! jpeg_fill_bit_buffer(&(state),get_buffer,bits_left,nbits))  \
+              { action; }  \
+            get_buffer = (state).get_buffer; bits_left = (state).bits_left; } }

 #define GET_BITS(nbits) \
-  (((int)(get_buffer >> (bits_left -= (nbits)))) & ((1 << (nbits)) - 1))
+        (((int) (get_buffer >> (bits_left -= (nbits)))) & ((1<<(nbits))-1))

 #define PEEK_BITS(nbits) \
-  (((int)(get_buffer >> (bits_left -  (nbits)))) & ((1 << (nbits)) - 1))
+        (((int) (get_buffer >> (bits_left -  (nbits)))) & ((1<<(nbits))-1))

 #define DROP_BITS(nbits) \
-  (bits_left -= (nbits))
+        (bits_left -= (nbits))

 /* Load up the bit buffer to a depth of at least nbits */
-EXTERN(boolean) jpeg_fill_bit_buffer(bitread_working_state *state,
-                                     register bit_buf_type get_buffer,
-                                     register int bits_left, int nbits);
+EXTERN(boolean) jpeg_fill_bit_buffer
+        (bitread_working_state *state, register bit_buf_type get_buffer,
+         register int bits_left, int nbits);


 /*
@@ -194,14 +187,13 @@ EXTERN(boolean) jpeg_fill_bit_buffer(bitread_working_state *state,
 * 3. jpeg_huff_decode returns -1 if forced to suspend.
 */

-#define HUFF_DECODE(result, state, htbl, failaction, slowlabel) { \
-  register int nb, look; \
+#define HUFF_DECODE(result,state,htbl,failaction,slowlabel) \
+{ register int nb, look; \
  if (bits_left < HUFF_LOOKAHEAD) { \
-    if (!jpeg_fill_bit_buffer(&state, get_buffer, bits_left, 0)) \
-      { failaction; } \
-    get_buffer = state.get_buffer;  bits_left = state.bits_left; \
+    if (! jpeg_fill_bit_buffer(&state,get_buffer,bits_left, 0)) {failaction;} \
+    get_buffer = state.get_buffer; bits_left = state.bits_left; \
    if (bits_left < HUFF_LOOKAHEAD) { \
-      nb = 1;  goto slowlabel; \
+      nb = 1; goto slowlabel; \
    } \
  } \
  look = PEEK_BITS(HUFF_LOOKAHEAD); \
@@ -210,14 +202,13 @@ EXTERN(boolean) jpeg_fill_bit_buffer(bitread_working_state *state,
    result = htbl->lookup[look] & ((1 << HUFF_LOOKAHEAD) - 1); \
  } else { \
 slowlabel: \
-    if ((result = \
-         jpeg_huff_decode(&state, get_buffer, bits_left, htbl, nb)) < 0) \
-      { failaction; } \
-    get_buffer = state.get_buffer;  bits_left = state.bits_left; \
+    if ((result=jpeg_huff_decode(&state,get_buffer,bits_left,htbl,nb)) < 0) \
+        { failaction; } \
+    get_buffer = state.get_buffer; bits_left = state.bits_left; \
  } \
 }

-#define HUFF_DECODE_FAST(s, nb, htbl) \
+#define HUFF_DECODE_FAST(s,nb,htbl) \
  FILL_BIT_BUFFER_FAST; \
  s = PEEK_BITS(HUFF_LOOKAHEAD); \
  s = htbl->lookup[s]; \
@@ -234,14 +225,10 @@ slowlabel: \
      s |= GET_BITS(1); \
      nb++; \
    } \
-    if (nb > 16) \
-      s = 0; \
-    else \
-      s = htbl->pub->huffval[(int)(s + htbl->valoffset[nb]) & 0xFF]; \
+    s = htbl->pub->huffval[ (int) (s + htbl->valoffset[nb]) & 0xFF ]; \
  }

 /* Out-of-line case for Huffman code fetching */
-EXTERN(int) jpeg_huff_decode(bitread_working_state *state,
-                             register bit_buf_type get_buffer,
-                             register int bits_left, d_derived_tbl *htbl,
-                             int min_bits);
+EXTERN(int) jpeg_huff_decode
+        (bitread_working_state *state, register bit_buf_type get_buffer,
+         register int bits_left, d_derived_tbl *htbl, int min_bits);
@@ -1,171 +0,0 @@
-/*
- * jdicc.c
- *
- * Copyright (C) 1997-1998, Thomas G. Lane, Todd Newman.
- * Copyright (C) 2017, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file provides code to read International Color Consortium (ICC) device
- * profiles embedded in JFIF JPEG image files.  The ICC has defined a standard
- * for including such data in JPEG "APP2" markers.  The code given here does
- * not know anything about the internal structure of the ICC profile data; it
- * just knows how to get the profile data from a JPEG file while reading it.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jerror.h"
-
-#ifndef HAVE_STDLIB_H           /* <stdlib.h> should declare malloc() */
-extern void *malloc(size_t size);
-#endif
-
-
-#define ICC_MARKER  (JPEG_APP0 + 2)     /* JPEG marker code for ICC */
-#define ICC_OVERHEAD_LEN  14            /* size of non-profile data in APP2 */
-
-
-/*
- * Handy subroutine to test whether a saved marker is an ICC profile marker.
- */
-
-LOCAL(boolean)
-marker_is_icc(jpeg_saved_marker_ptr marker)
-{
-  return
-    marker->marker == ICC_MARKER &&
-    marker->data_length >= ICC_OVERHEAD_LEN &&
-    /* verify the identifying string */
-    marker->data[0] == 0x49 &&
-    marker->data[1] == 0x43 &&
-    marker->data[2] == 0x43 &&
-    marker->data[3] == 0x5F &&
-    marker->data[4] == 0x50 &&
-    marker->data[5] == 0x52 &&
-    marker->data[6] == 0x4F &&
-    marker->data[7] == 0x46 &&
-    marker->data[8] == 0x49 &&
-    marker->data[9] == 0x4C &&
-    marker->data[10] == 0x45 &&
-    marker->data[11] == 0x0;
-}
-
-
-/*
- * See if there was an ICC profile in the JPEG file being read; if so,
- * reassemble and return the profile data.
- *
- * TRUE is returned if an ICC profile was found, FALSE if not.  If TRUE is
- * returned, *icc_data_ptr is set to point to the returned data, and
- * *icc_data_len is set to its length.
- *
- * IMPORTANT: the data at *icc_data_ptr is allocated with malloc() and must be
- * freed by the caller with free() when the caller no longer needs it.
- * (Alternatively, we could write this routine to use the IJG library's memory
- * allocator, so that the data would be freed implicitly when
- * jpeg_finish_decompress() is called.  But it seems likely that many
- * applications will prefer to have the data stick around after decompression
- * finishes.)
- */
-
-GLOBAL(boolean)
-jpeg_read_icc_profile(j_decompress_ptr cinfo, JOCTET **icc_data_ptr,
-                      unsigned int *icc_data_len)
-{
-  jpeg_saved_marker_ptr marker;
-  int num_markers = 0;
-  int seq_no;
-  JOCTET *icc_data;
-  unsigned int total_length;
-#define MAX_SEQ_NO  255         /* sufficient since marker numbers are bytes */
-  char marker_present[MAX_SEQ_NO + 1];      /* 1 if marker found */
-  unsigned int data_length[MAX_SEQ_NO + 1]; /* size of profile data in marker */
-  unsigned int data_offset[MAX_SEQ_NO + 1]; /* offset for data in marker */
-
-  if (icc_data_ptr == NULL || icc_data_len == NULL)
-    ERREXIT(cinfo, JERR_BUFFER_SIZE);
-  if (cinfo->global_state < DSTATE_READY)
-    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
-
-  *icc_data_ptr = NULL;         /* avoid confusion if FALSE return */
-  *icc_data_len = 0;
-
-  /* This first pass over the saved markers discovers whether there are
-   * any ICC markers and verifies the consistency of the marker numbering.
-   */
-
-  for (seq_no = 1; seq_no <= MAX_SEQ_NO; seq_no++)
-    marker_present[seq_no] = 0;
-
-  for (marker = cinfo->marker_list; marker != NULL; marker = marker->next) {
-    if (marker_is_icc(marker)) {
-      if (num_markers == 0)
-        num_markers = marker->data[13];
-      else if (num_markers != marker->data[13]) {
-        WARNMS(cinfo, JWRN_BOGUS_ICC);  /* inconsistent num_markers fields */
-        return FALSE;
-      }
-      seq_no = marker->data[12];
-      if (seq_no <= 0 || seq_no > num_markers) {
-        WARNMS(cinfo, JWRN_BOGUS_ICC);  /* bogus sequence number */
-        return FALSE;
-      }
-      if (marker_present[seq_no]) {
-        WARNMS(cinfo, JWRN_BOGUS_ICC);  /* duplicate sequence numbers */
-        return FALSE;
-      }
-      marker_present[seq_no] = 1;
-      data_length[seq_no] = marker->data_length - ICC_OVERHEAD_LEN;
-    }
-  }
-
-  if (num_markers == 0)
-    return FALSE;
-
-  /* Check for missing markers, count total space needed,
-   * compute offset of each marker's part of the data.
-   */
-
-  total_length = 0;
-  for (seq_no = 1; seq_no <= num_markers; seq_no++) {
-    if (marker_present[seq_no] == 0) {
-      WARNMS(cinfo, JWRN_BOGUS_ICC);  /* missing sequence number */
-      return FALSE;
-    }
-    data_offset[seq_no] = total_length;
-    total_length += data_length[seq_no];
-  }
-
-  if (total_length == 0) {
-    WARNMS(cinfo, JWRN_BOGUS_ICC);  /* found only empty markers? */
-    return FALSE;
-  }
-
-  /* Allocate space for assembled data */
-  icc_data = (JOCTET *)malloc(total_length * sizeof(JOCTET));
-  if (icc_data == NULL)
-    ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 11);  /* oops, out of memory */
-
-  /* and fill it in */
-  for (marker = cinfo->marker_list; marker != NULL; marker = marker->next) {
-    if (marker_is_icc(marker)) {
-      JOCTET FAR *src_ptr;
-      JOCTET *dst_ptr;
-      unsigned int length;
-      seq_no = marker->data[12];
-      dst_ptr = icc_data + data_offset[seq_no];
-      src_ptr = marker->data + ICC_OVERHEAD_LEN;
-      length = data_length[seq_no];
-      while (length--) {
-        *dst_ptr++ = *src_ptr++;
-      }
-    }
-  }
-
-  *icc_data_ptr = icc_data;
-  *icc_data_len = total_length;
-
-  return TRUE;
-}
@@ -4,7 +4,7 @@
 * This file was part of the Independent JPEG Group's software:
 * Copyright (C) 1991-1997, Thomas G. Lane.
 * libjpeg-turbo Modifications:
- * Copyright (C) 2010, 2016, 2018, D. R. Commander.
+ * Copyright (C) 2010, 2016, D. R. Commander.
 * Copyright (C) 2015, Google, Inc.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
@@ -33,7 +33,7 @@ typedef my_input_controller *my_inputctl_ptr;


 /* Forward declarations */
-METHODDEF(int) consume_markers(j_decompress_ptr cinfo);
+METHODDEF(int) consume_markers (j_decompress_ptr cinfo);


 /*
@@ -41,16 +41,16 @@ METHODDEF(int) consume_markers(j_decompress_ptr cinfo);
 */

 LOCAL(void)
-initial_setup(j_decompress_ptr cinfo)
+initial_setup (j_decompress_ptr cinfo)
 /* Called once, when first SOS marker is reached */
 {
  int ci;
  jpeg_component_info *compptr;

  /* Make sure image isn't bigger than I can handle */
-  if ((long)cinfo->image_height > (long)JPEG_MAX_DIMENSION ||
-      (long)cinfo->image_width > (long)JPEG_MAX_DIMENSION)
-    ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int)JPEG_MAX_DIMENSION);
+  if ((long) cinfo->image_height > (long) JPEG_MAX_DIMENSION ||
+      (long) cinfo->image_width > (long) JPEG_MAX_DIMENSION)
+    ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) JPEG_MAX_DIMENSION);

  /* For now, precision must match compiled-in value... */
  if (cinfo->data_precision != BITS_IN_JSAMPLE)
@@ -66,10 +66,8 @@ initial_setup(j_decompress_ptr cinfo)
  cinfo->max_v_samp_factor = 1;
  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
       ci++, compptr++) {
-    if (compptr->h_samp_factor <= 0 ||
-        compptr->h_samp_factor > MAX_SAMP_FACTOR ||
-        compptr->v_samp_factor <= 0 ||
-        compptr->v_samp_factor > MAX_SAMP_FACTOR)
+    if (compptr->h_samp_factor<=0 || compptr->h_samp_factor>MAX_SAMP_FACTOR ||
+        compptr->v_samp_factor<=0 || compptr->v_samp_factor>MAX_SAMP_FACTOR)
      ERREXIT(cinfo, JERR_BAD_SAMPLING);
    cinfo->max_h_samp_factor = MAX(cinfo->max_h_samp_factor,
                                   compptr->h_samp_factor);
@@ -77,10 +75,10 @@ initial_setup(j_decompress_ptr cinfo)
                                   compptr->v_samp_factor);
  }

-#if JPEG_LIB_VERSION >= 80
-  cinfo->block_size = DCTSIZE;
-  cinfo->natural_order = jpeg_natural_order;
-  cinfo->lim_Se = DCTSIZE2 - 1;
+#if JPEG_LIB_VERSION >=80
+    cinfo->block_size = DCTSIZE;
+    cinfo->natural_order = jpeg_natural_order;
+    cinfo->lim_Se = DCTSIZE2-1;
 #endif

  /* We initialize DCT_scaled_size and min_DCT_scaled_size to DCTSIZE.
@@ -103,11 +101,11 @@ initial_setup(j_decompress_ptr cinfo)
 #endif
    /* Size in DCT blocks */
    compptr->width_in_blocks = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_width * (long)compptr->h_samp_factor,
-                    (long)(cinfo->max_h_samp_factor * DCTSIZE));
+      jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
+                    (long) (cinfo->max_h_samp_factor * DCTSIZE));
    compptr->height_in_blocks = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_height * (long)compptr->v_samp_factor,
-                    (long)(cinfo->max_v_samp_factor * DCTSIZE));
+      jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
+                    (long) (cinfo->max_v_samp_factor * DCTSIZE));
    /* Set the first and last MCU columns to decompress from multi-scan images.
     * By default, decompress all of the MCU columns.
     */
@@ -119,11 +117,11 @@ initial_setup(j_decompress_ptr cinfo)
     */
    /* Size in samples */
    compptr->downsampled_width = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_width * (long)compptr->h_samp_factor,
-                    (long)cinfo->max_h_samp_factor);
+      jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
+                    (long) cinfo->max_h_samp_factor);
    compptr->downsampled_height = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_height * (long)compptr->v_samp_factor,
-                    (long)cinfo->max_v_samp_factor);
+      jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
+                    (long) cinfo->max_v_samp_factor);
    /* Mark component needed, until color conversion says otherwise */
    compptr->component_needed = TRUE;
    /* Mark no quantization table yet saved for component */
@@ -132,8 +130,8 @@ initial_setup(j_decompress_ptr cinfo)

  /* Compute number of fully interleaved MCU rows. */
  cinfo->total_iMCU_rows = (JDIMENSION)
-    jdiv_round_up((long)cinfo->image_height,
-                  (long)(cinfo->max_v_samp_factor * DCTSIZE));
+    jdiv_round_up((long) cinfo->image_height,
+                  (long) (cinfo->max_v_samp_factor*DCTSIZE));

  /* Decide whether file contains multiple scans */
  if (cinfo->comps_in_scan < cinfo->num_components || cinfo->progressive_mode)
@@ -144,7 +142,7 @@ initial_setup(j_decompress_ptr cinfo)


 LOCAL(void)
-per_scan_setup(j_decompress_ptr cinfo)
+per_scan_setup (j_decompress_ptr cinfo)
 /* Do computations that are needed before processing a JPEG scan */
 /* cinfo->comps_in_scan and cinfo->cur_comp_info[] were set from SOS marker */
 {
@@ -169,7 +167,7 @@ per_scan_setup(j_decompress_ptr cinfo)
    /* For noninterleaved scans, it is convenient to define last_row_height
     * as the number of block rows present in the last iMCU row.
     */
-    tmp = (int)(compptr->height_in_blocks % compptr->v_samp_factor);
+    tmp = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
    if (tmp == 0) tmp = compptr->v_samp_factor;
    compptr->last_row_height = tmp;

@@ -186,11 +184,11 @@ per_scan_setup(j_decompress_ptr cinfo)

    /* Overall image size in MCUs */
    cinfo->MCUs_per_row = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_width,
-                    (long)(cinfo->max_h_samp_factor * DCTSIZE));
+      jdiv_round_up((long) cinfo->image_width,
+                    (long) (cinfo->max_h_samp_factor*DCTSIZE));
    cinfo->MCU_rows_in_scan = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_height,
-                    (long)(cinfo->max_v_samp_factor * DCTSIZE));
+      jdiv_round_up((long) cinfo->image_height,
+                    (long) (cinfo->max_v_samp_factor*DCTSIZE));

    cinfo->blocks_in_MCU = 0;

@@ -200,13 +198,12 @@ per_scan_setup(j_decompress_ptr cinfo)
      compptr->MCU_width = compptr->h_samp_factor;
      compptr->MCU_height = compptr->v_samp_factor;
      compptr->MCU_blocks = compptr->MCU_width * compptr->MCU_height;
-      compptr->MCU_sample_width = compptr->MCU_width *
-                                  compptr->_DCT_scaled_size;
+      compptr->MCU_sample_width = compptr->MCU_width * compptr->_DCT_scaled_size;
      /* Figure number of non-dummy blocks in last MCU column & row */
-      tmp = (int)(compptr->width_in_blocks % compptr->MCU_width);
+      tmp = (int) (compptr->width_in_blocks % compptr->MCU_width);
      if (tmp == 0) tmp = compptr->MCU_width;
      compptr->last_col_width = tmp;
-      tmp = (int)(compptr->height_in_blocks % compptr->MCU_height);
+      tmp = (int) (compptr->height_in_blocks % compptr->MCU_height);
      if (tmp == 0) tmp = compptr->MCU_height;
      compptr->last_row_height = tmp;
      /* Prepare array describing MCU composition */
@@ -234,17 +231,17 @@ per_scan_setup(j_decompress_ptr cinfo)
 * means that we have to save away the table actually used for each component.
 * We do this by copying the table at the start of the first scan containing
 * the component.
- * Rec. ITU-T T.81 | ISO/IEC 10918-1 prohibits the encoder from changing the
- * contents of a Q-table slot between scans of a component using that slot.  If
- * the encoder does so anyway, this decoder will simply use the Q-table values
- * that were current at the start of the first scan for the component.
+ * The JPEG spec prohibits the encoder from changing the contents of a Q-table
+ * slot between scans of a component using that slot.  If the encoder does so
+ * anyway, this decoder will simply use the Q-table values that were current
+ * at the start of the first scan for the component.
 *
 * The decompressor output side looks only at the saved quant tables,
 * not at the current Q-table slots.
 */

 LOCAL(void)
-latch_quant_tables(j_decompress_ptr cinfo)
+latch_quant_tables (j_decompress_ptr cinfo)
 {
  int ci, qtblno;
  jpeg_component_info *compptr;
@@ -262,7 +259,7 @@ latch_quant_tables(j_decompress_ptr cinfo)
      ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno);
    /* OK, save away the quantization table */
    qtbl = (JQUANT_TBL *)
-      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                  sizeof(JQUANT_TBL));
    MEMCOPY(qtbl, cinfo->quant_tbl_ptrs[qtblno], sizeof(JQUANT_TBL));
    compptr->quant_table = qtbl;
@@ -278,7 +275,7 @@ latch_quant_tables(j_decompress_ptr cinfo)
 */

 METHODDEF(void)
-start_input_pass(j_decompress_ptr cinfo)
+start_input_pass (j_decompress_ptr cinfo)
 {
  per_scan_setup(cinfo);
  latch_quant_tables(cinfo);
@@ -295,7 +292,7 @@ start_input_pass(j_decompress_ptr cinfo)
 */

 METHODDEF(void)
-finish_input_pass(j_decompress_ptr cinfo)
+finish_input_pass (j_decompress_ptr cinfo)
 {
  cinfo->inputctl->consume_input = consume_markers;
 }
@@ -312,9 +309,9 @@ finish_input_pass(j_decompress_ptr cinfo)
 */

 METHODDEF(int)
-consume_markers(j_decompress_ptr cinfo)
+consume_markers (j_decompress_ptr cinfo)
 {
-  my_inputctl_ptr inputctl = (my_inputctl_ptr)cinfo->inputctl;
+  my_inputctl_ptr inputctl = (my_inputctl_ptr) cinfo->inputctl;
  int val;

  if (inputctl->pub.eoi_reached) /* After hitting EOI, read no further */
@@ -332,7 +329,7 @@ consume_markers(j_decompress_ptr cinfo)
       * responsible for enforcing this sequencing.
       */
    } else {                    /* 2nd or later SOS marker */
-      if (!inputctl->pub.has_multiple_scans)
+      if (! inputctl->pub.has_multiple_scans)
        ERREXIT(cinfo, JERR_EOI_EXPECTED); /* Oops, I wasn't expecting this! */
      start_input_pass(cinfo);
    }
@@ -363,16 +360,16 @@ consume_markers(j_decompress_ptr cinfo)
 */

 METHODDEF(void)
-reset_input_controller(j_decompress_ptr cinfo)
+reset_input_controller (j_decompress_ptr cinfo)
 {
-  my_inputctl_ptr inputctl = (my_inputctl_ptr)cinfo->inputctl;
+  my_inputctl_ptr inputctl = (my_inputctl_ptr) cinfo->inputctl;

  inputctl->pub.consume_input = consume_markers;
  inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */
  inputctl->pub.eoi_reached = FALSE;
  inputctl->inheaders = TRUE;
  /* Reset other modules */
-  (*cinfo->err->reset_error_mgr) ((j_common_ptr)cinfo);
+  (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
  (*cinfo->marker->reset_marker_reader) (cinfo);
  /* Reset progression state -- would be cleaner if entropy decoder did this */
  cinfo->coef_bits = NULL;
@@ -385,15 +382,15 @@ reset_input_controller(j_decompress_ptr cinfo)
 */

 GLOBAL(void)
-jinit_input_controller(j_decompress_ptr cinfo)
+jinit_input_controller (j_decompress_ptr cinfo)
 {
  my_inputctl_ptr inputctl;

  /* Create subobject in permanent pool */
  inputctl = (my_inputctl_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
                                sizeof(my_input_controller));
-  cinfo->inputctl = (struct jpeg_input_controller *)inputctl;
+  cinfo->inputctl = (struct jpeg_input_controller *) inputctl;
  /* Initialize method pointers */
  inputctl->pub.consume_input = consume_markers;
  inputctl->pub.reset_input_controller = reset_input_controller;
@@ -18,7 +18,6 @@

 #include "jinclude.h"
 #include "jdmainct.h"
-#include "jconfigint.h"


 /*
@@ -113,29 +112,26 @@


 /* Forward declarations */
-METHODDEF(void) process_data_simple_main(j_decompress_ptr cinfo,
-                                         JSAMPARRAY output_buf,
-                                         JDIMENSION *out_row_ctr,
-                                         JDIMENSION out_rows_avail);
-METHODDEF(void) process_data_context_main(j_decompress_ptr cinfo,
-                                          JSAMPARRAY output_buf,
-                                          JDIMENSION *out_row_ctr,
-                                          JDIMENSION out_rows_avail);
+METHODDEF(void) process_data_simple_main
+        (j_decompress_ptr cinfo, JSAMPARRAY output_buf,
+         JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail);
+METHODDEF(void) process_data_context_main
+        (j_decompress_ptr cinfo, JSAMPARRAY output_buf,
+         JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail);
 #ifdef QUANT_2PASS_SUPPORTED
-METHODDEF(void) process_data_crank_post(j_decompress_ptr cinfo,
-                                        JSAMPARRAY output_buf,
-                                        JDIMENSION *out_row_ctr,
-                                        JDIMENSION out_rows_avail);
+METHODDEF(void) process_data_crank_post
+        (j_decompress_ptr cinfo, JSAMPARRAY output_buf,
+         JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail);
 #endif


 LOCAL(void)
-alloc_funny_pointers(j_decompress_ptr cinfo)
+alloc_funny_pointers (j_decompress_ptr cinfo)
 /* Allocate space for the funny pointer lists.
 * This is done only once, not once per pass.
 */
 {
-  my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
+  my_main_ptr main_ptr = (my_main_ptr) cinfo->main;
  int ci, rgroup;
  int M = cinfo->_min_DCT_scaled_size;
  jpeg_component_info *compptr;
@@ -145,7 +141,7 @@ alloc_funny_pointers(j_decompress_ptr cinfo)
   * We alloc both arrays with one call to save a few cycles.
   */
  main_ptr->xbuffer[0] = (JSAMPIMAGE)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                cinfo->num_components * 2 * sizeof(JSAMPARRAY));
  main_ptr->xbuffer[1] = main_ptr->xbuffer[0] + cinfo->num_components;

@@ -157,7 +153,7 @@ alloc_funny_pointers(j_decompress_ptr cinfo)
     * We alloc both pointer lists with one call to save a few cycles.
     */
    xbuf = (JSAMPARRAY)
-      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                  2 * (rgroup * (M + 4)) * sizeof(JSAMPROW));
    xbuf += rgroup;             /* want one row group at negative offsets */
    main_ptr->xbuffer[0][ci] = xbuf;
@@ -168,7 +164,7 @@ alloc_funny_pointers(j_decompress_ptr cinfo)


 LOCAL(void)
-make_funny_pointers(j_decompress_ptr cinfo)
+make_funny_pointers (j_decompress_ptr cinfo)
 /* Create the funny pointer lists discussed in the comments above.
 * The actual workspace is already allocated (in main_ptr->buffer),
 * and the space for the pointer lists is allocated too.
@@ -176,7 +172,7 @@ make_funny_pointers(j_decompress_ptr cinfo)
 * This will be repeated at the beginning of each pass.
 */
 {
-  my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
+  my_main_ptr main_ptr = (my_main_ptr) cinfo->main;
  int ci, i, rgroup;
  int M = cinfo->_min_DCT_scaled_size;
  jpeg_component_info *compptr;
@@ -195,8 +191,8 @@ make_funny_pointers(j_decompress_ptr cinfo)
    }
    /* In the second list, put the last four row groups in swapped order */
    for (i = 0; i < rgroup * 2; i++) {
-      xbuf1[rgroup * (M - 2) + i] = buf[rgroup * M + i];
-      xbuf1[rgroup * M + i] = buf[rgroup * (M - 2) + i];
+      xbuf1[rgroup*(M-2) + i] = buf[rgroup*M + i];
+      xbuf1[rgroup*M + i] = buf[rgroup*(M-2) + i];
    }
    /* The wraparound pointers at top and bottom will be filled later
     * (see set_wraparound_pointers, below).  Initially we want the "above"
@@ -211,13 +207,13 @@ make_funny_pointers(j_decompress_ptr cinfo)


 LOCAL(void)
-set_bottom_pointers(j_decompress_ptr cinfo)
+set_bottom_pointers (j_decompress_ptr cinfo)
 /* Change the pointer lists to duplicate the last sample row at the bottom
 * of the image.  whichptr indicates which xbuffer holds the final iMCU row.
 * Also sets rowgroups_avail to indicate number of nondummy row groups in row.
 */
 {
-  my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
+  my_main_ptr main_ptr = (my_main_ptr) cinfo->main;
  int ci, i, rgroup, iMCUheight, rows_left;
  jpeg_component_info *compptr;
  JSAMPARRAY xbuf;
@@ -228,20 +224,20 @@ set_bottom_pointers(j_decompress_ptr cinfo)
    iMCUheight = compptr->v_samp_factor * compptr->_DCT_scaled_size;
    rgroup = iMCUheight / cinfo->_min_DCT_scaled_size;
    /* Count nondummy sample rows remaining for this component */
-    rows_left = (int)(compptr->downsampled_height % (JDIMENSION)iMCUheight);
+    rows_left = (int) (compptr->downsampled_height % (JDIMENSION) iMCUheight);
    if (rows_left == 0) rows_left = iMCUheight;
    /* Count nondummy row groups.  Should get same answer for each component,
     * so we need only do it once.
     */
    if (ci == 0) {
-      main_ptr->rowgroups_avail = (JDIMENSION)((rows_left - 1) / rgroup + 1);
+      main_ptr->rowgroups_avail = (JDIMENSION) ((rows_left-1) / rgroup + 1);
    }
    /* Duplicate the last real sample row rgroup*2 times; this pads out the
     * last partial rowgroup and ensures at least one full rowgroup of context.
     */
    xbuf = main_ptr->xbuffer[main_ptr->whichptr][ci];
    for (i = 0; i < rgroup * 2; i++) {
-      xbuf[rows_left + i] = xbuf[rows_left - 1];
+      xbuf[rows_left + i] = xbuf[rows_left-1];
    }
  }
 }
@@ -252,9 +248,9 @@ set_bottom_pointers(j_decompress_ptr cinfo)
 */

 METHODDEF(void)
-start_pass_main(j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
+start_pass_main (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
 {
-  my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
+  my_main_ptr main_ptr = (my_main_ptr) cinfo->main;

  switch (pass_mode) {
  case JBUF_PASS_THRU:
@@ -290,21 +286,22 @@ start_pass_main(j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
 */

 METHODDEF(void)
-process_data_simple_main(j_decompress_ptr cinfo, JSAMPARRAY output_buf,
-                         JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
+process_data_simple_main (j_decompress_ptr cinfo,
+                          JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+                          JDIMENSION out_rows_avail)
 {
-  my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
+  my_main_ptr main_ptr = (my_main_ptr) cinfo->main;
  JDIMENSION rowgroups_avail;

  /* Read input data if we haven't filled the main buffer yet */
-  if (!main_ptr->buffer_full) {
-    if (!(*cinfo->coef->decompress_data) (cinfo, main_ptr->buffer))
+  if (! main_ptr->buffer_full) {
+    if (! (*cinfo->coef->decompress_data) (cinfo, main_ptr->buffer))
      return;                   /* suspension forced, can do nothing more */
    main_ptr->buffer_full = TRUE;       /* OK, we have an iMCU row to work with */
  }

  /* There are always min_DCT_scaled_size row groups in an iMCU row. */
-  rowgroups_avail = (JDIMENSION)cinfo->_min_DCT_scaled_size;
+  rowgroups_avail = (JDIMENSION) cinfo->_min_DCT_scaled_size;
  /* Note: at the bottom of the image, we may pass extra garbage row groups
   * to the postprocessor.  The postprocessor has to check for bottom
   * of image anyway (at row resolution), so no point in us doing it too.
@@ -329,15 +326,16 @@ process_data_simple_main(j_decompress_ptr cinfo, JSAMPARRAY output_buf,
 */

 METHODDEF(void)
-process_data_context_main(j_decompress_ptr cinfo, JSAMPARRAY output_buf,
-                          JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
+process_data_context_main (j_decompress_ptr cinfo,
+                           JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+                           JDIMENSION out_rows_avail)
 {
-  my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
+  my_main_ptr main_ptr = (my_main_ptr) cinfo->main;

  /* Read input data if we haven't filled the main buffer yet */
-  if (!main_ptr->buffer_full) {
-    if (!(*cinfo->coef->decompress_data) (cinfo,
-                                          main_ptr->xbuffer[main_ptr->whichptr]))
+  if (! main_ptr->buffer_full) {
+    if (! (*cinfo->coef->decompress_data) (cinfo,
+                                           main_ptr->xbuffer[main_ptr->whichptr]))
      return;                   /* suspension forced, can do nothing more */
    main_ptr->buffer_full = TRUE;       /* OK, we have an iMCU row to work with */
    main_ptr->iMCU_row_ctr++;   /* count rows received */
@@ -351,35 +349,31 @@ process_data_context_main(j_decompress_ptr cinfo, JSAMPARRAY output_buf,
  switch (main_ptr->context_state) {
  case CTX_POSTPONED_ROW:
    /* Call postprocessor using previously set pointers for postponed row */
-    (*cinfo->post->post_process_data) (cinfo,
-                                       main_ptr->xbuffer[main_ptr->whichptr],
-                                       &main_ptr->rowgroup_ctr,
-                                       main_ptr->rowgroups_avail, output_buf,
-                                       out_row_ctr, out_rows_avail);
+    (*cinfo->post->post_process_data) (cinfo, main_ptr->xbuffer[main_ptr->whichptr],
+                        &main_ptr->rowgroup_ctr, main_ptr->rowgroups_avail,
+                        output_buf, out_row_ctr, out_rows_avail);
    if (main_ptr->rowgroup_ctr < main_ptr->rowgroups_avail)
      return;                   /* Need to suspend */
    main_ptr->context_state = CTX_PREPARE_FOR_IMCU;
    if (*out_row_ctr >= out_rows_avail)
      return;                   /* Postprocessor exactly filled output buf */
-    FALLTHROUGH                 /*FALLTHROUGH*/
+    /*FALLTHROUGH*/
  case CTX_PREPARE_FOR_IMCU:
    /* Prepare to process first M-1 row groups of this iMCU row */
    main_ptr->rowgroup_ctr = 0;
-    main_ptr->rowgroups_avail = (JDIMENSION)(cinfo->_min_DCT_scaled_size - 1);
+    main_ptr->rowgroups_avail = (JDIMENSION) (cinfo->_min_DCT_scaled_size - 1);
    /* Check for bottom of image: if so, tweak pointers to "duplicate"
     * the last sample row, and adjust rowgroups_avail to ignore padding rows.
     */
    if (main_ptr->iMCU_row_ctr == cinfo->total_iMCU_rows)
      set_bottom_pointers(cinfo);
    main_ptr->context_state = CTX_PROCESS_IMCU;
-    FALLTHROUGH                 /*FALLTHROUGH*/
+    /*FALLTHROUGH*/
  case CTX_PROCESS_IMCU:
    /* Call postprocessor using previously set pointers */
-    (*cinfo->post->post_process_data) (cinfo,
-                                       main_ptr->xbuffer[main_ptr->whichptr],
-                                       &main_ptr->rowgroup_ctr,
-                                       main_ptr->rowgroups_avail, output_buf,
-                                       out_row_ctr, out_rows_avail);
+    (*cinfo->post->post_process_data) (cinfo, main_ptr->xbuffer[main_ptr->whichptr],
+                        &main_ptr->rowgroup_ctr, main_ptr->rowgroups_avail,
+                        output_buf, out_row_ctr, out_rows_avail);
    if (main_ptr->rowgroup_ctr < main_ptr->rowgroups_avail)
      return;                   /* Need to suspend */
    /* After the first iMCU, change wraparound pointers to normal state */
@@ -390,8 +384,8 @@ process_data_context_main(j_decompress_ptr cinfo, JSAMPARRAY output_buf,
    main_ptr->buffer_full = FALSE;
    /* Still need to process last row group of this iMCU row, */
    /* which is saved at index M+1 of the other xbuffer */
-    main_ptr->rowgroup_ctr = (JDIMENSION)(cinfo->_min_DCT_scaled_size + 1);
-    main_ptr->rowgroups_avail = (JDIMENSION)(cinfo->_min_DCT_scaled_size + 2);
+    main_ptr->rowgroup_ctr = (JDIMENSION) (cinfo->_min_DCT_scaled_size + 1);
+    main_ptr->rowgroups_avail = (JDIMENSION) (cinfo->_min_DCT_scaled_size + 2);
    main_ptr->context_state = CTX_POSTPONED_ROW;
  }
 }
@@ -406,11 +400,12 @@ process_data_context_main(j_decompress_ptr cinfo, JSAMPARRAY output_buf,
 #ifdef QUANT_2PASS_SUPPORTED

 METHODDEF(void)
-process_data_crank_post(j_decompress_ptr cinfo, JSAMPARRAY output_buf,
-                        JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
+process_data_crank_post (j_decompress_ptr cinfo,
+                         JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+                         JDIMENSION out_rows_avail)
 {
-  (*cinfo->post->post_process_data) (cinfo, (JSAMPIMAGE)NULL,
-                                     (JDIMENSION *)NULL, (JDIMENSION)0,
+  (*cinfo->post->post_process_data) (cinfo, (JSAMPIMAGE) NULL,
+                                     (JDIMENSION *) NULL, (JDIMENSION) 0,
                                     output_buf, out_row_ctr, out_rows_avail);
 }

@@ -422,16 +417,16 @@ process_data_crank_post(j_decompress_ptr cinfo, JSAMPARRAY output_buf,
 */

 GLOBAL(void)
-jinit_d_main_controller(j_decompress_ptr cinfo, boolean need_full_buffer)
+jinit_d_main_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
 {
  my_main_ptr main_ptr;
  int ci, rgroup, ngroups;
  jpeg_component_info *compptr;

  main_ptr = (my_main_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                sizeof(my_main_controller));
-  cinfo->main = (struct jpeg_d_main_controller *)main_ptr;
+  cinfo->main = (struct jpeg_d_main_controller *) main_ptr;
  main_ptr->pub.start_pass = start_pass_main;

  if (need_full_buffer)         /* shouldn't happen */
@@ -454,8 +449,8 @@ jinit_d_main_controller(j_decompress_ptr cinfo, boolean need_full_buffer)
    rgroup = (compptr->v_samp_factor * compptr->_DCT_scaled_size) /
      cinfo->_min_DCT_scaled_size; /* height of a row group of component */
    main_ptr->buffer[ci] = (*cinfo->mem->alloc_sarray)
-                        ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                        ((j_common_ptr) cinfo, JPOOL_IMAGE,
                         compptr->width_in_blocks * compptr->_DCT_scaled_size,
-                         (JDIMENSION)(rgroup * ngroups));
+                         (JDIMENSION) (rgroup * ngroups));
  }
 }
@@ -44,12 +44,12 @@ typedef my_main_controller *my_main_ptr;


 LOCAL(void)
-set_wraparound_pointers(j_decompress_ptr cinfo)
+set_wraparound_pointers (j_decompress_ptr cinfo)
 /* Set up the "wraparound" pointers at top and bottom of the pointer lists.
 * This changes the pointer list state from top-of-image to the normal state.
 */
 {
-  my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
+  my_main_ptr main_ptr = (my_main_ptr) cinfo->main;
  int ci, i, rgroup;
  int M = cinfo->_min_DCT_scaled_size;
  jpeg_component_info *compptr;
@@ -62,10 +62,10 @@ set_wraparound_pointers(j_decompress_ptr cinfo)
    xbuf0 = main_ptr->xbuffer[0][ci];
    xbuf1 = main_ptr->xbuffer[1][ci];
    for (i = 0; i < rgroup; i++) {
-      xbuf0[i - rgroup] = xbuf0[rgroup * (M + 1) + i];
-      xbuf1[i - rgroup] = xbuf1[rgroup * (M + 1) + i];
-      xbuf0[rgroup * (M + 2) + i] = xbuf0[i];
-      xbuf1[rgroup * (M + 2) + i] = xbuf1[i];
+      xbuf0[i - rgroup] = xbuf0[rgroup*(M+1) + i];
+      xbuf1[i - rgroup] = xbuf1[rgroup*(M+1) + i];
+      xbuf0[rgroup*(M+2) + i] = xbuf0[i];
+      xbuf1[rgroup*(M+2) + i] = xbuf1[i];
    }
  }
 }
@@ -119,50 +119,50 @@ typedef my_marker_reader *my_marker_ptr;
 */

 /* Declare and initialize local copies of input pointer/count */
-#define INPUT_VARS(cinfo) \
-  struct jpeg_source_mgr *datasrc = (cinfo)->src; \
-  const JOCTET *next_input_byte = datasrc->next_input_byte; \
-  size_t bytes_in_buffer = datasrc->bytes_in_buffer
+#define INPUT_VARS(cinfo)  \
+        struct jpeg_source_mgr *datasrc = (cinfo)->src;  \
+        const JOCTET *next_input_byte = datasrc->next_input_byte;  \
+        size_t bytes_in_buffer = datasrc->bytes_in_buffer

 /* Unload the local copies --- do this only at a restart boundary */
-#define INPUT_SYNC(cinfo) \
-  ( datasrc->next_input_byte = next_input_byte, \
-    datasrc->bytes_in_buffer = bytes_in_buffer )
+#define INPUT_SYNC(cinfo)  \
+        ( datasrc->next_input_byte = next_input_byte,  \
+          datasrc->bytes_in_buffer = bytes_in_buffer )

 /* Reload the local copies --- used only in MAKE_BYTE_AVAIL */
-#define INPUT_RELOAD(cinfo) \
-  ( next_input_byte = datasrc->next_input_byte, \
-    bytes_in_buffer = datasrc->bytes_in_buffer )
+#define INPUT_RELOAD(cinfo)  \
+        ( next_input_byte = datasrc->next_input_byte,  \
+          bytes_in_buffer = datasrc->bytes_in_buffer )

 /* Internal macro for INPUT_BYTE and INPUT_2BYTES: make a byte available.
 * Note we do *not* do INPUT_SYNC before calling fill_input_buffer,
 * but we must reload the local copies after a successful fill.
 */
-#define MAKE_BYTE_AVAIL(cinfo, action) \
-  if (bytes_in_buffer == 0) { \
-    if (!(*datasrc->fill_input_buffer) (cinfo)) \
-      { action; } \
-    INPUT_RELOAD(cinfo); \
-  }
+#define MAKE_BYTE_AVAIL(cinfo,action)  \
+        if (bytes_in_buffer == 0) {  \
+          if (! (*datasrc->fill_input_buffer) (cinfo))  \
+            { action; }  \
+          INPUT_RELOAD(cinfo);  \
+        }

 /* Read a byte into variable V.
 * If must suspend, take the specified action (typically "return FALSE").
 */
-#define INPUT_BYTE(cinfo, V, action) \
-  MAKESTMT( MAKE_BYTE_AVAIL(cinfo, action); \
-            bytes_in_buffer--; \
-            V = *next_input_byte++; )
+#define INPUT_BYTE(cinfo,V,action)  \
+        MAKESTMT( MAKE_BYTE_AVAIL(cinfo,action); \
+                  bytes_in_buffer--; \
+                  V = GETJOCTET(*next_input_byte++); )

 /* As above, but read two bytes interpreted as an unsigned 16-bit integer.
 * V should be declared unsigned int or perhaps JLONG.
 */
-#define INPUT_2BYTES(cinfo, V, action) \
-  MAKESTMT( MAKE_BYTE_AVAIL(cinfo, action); \
-            bytes_in_buffer--; \
-            V = ((unsigned int)(*next_input_byte++)) << 8; \
-            MAKE_BYTE_AVAIL(cinfo, action); \
-            bytes_in_buffer--; \
-            V += *next_input_byte++; )
+#define INPUT_2BYTES(cinfo,V,action)  \
+        MAKESTMT( MAKE_BYTE_AVAIL(cinfo,action); \
+                  bytes_in_buffer--; \
+                  V = ((unsigned int) GETJOCTET(*next_input_byte++)) << 8; \
+                  MAKE_BYTE_AVAIL(cinfo,action); \
+                  bytes_in_buffer--; \
+                  V += GETJOCTET(*next_input_byte++); )


 /*
@@ -197,7 +197,7 @@ typedef my_marker_reader *my_marker_ptr;


 LOCAL(boolean)
-get_soi(j_decompress_ptr cinfo)
+get_soi (j_decompress_ptr cinfo)
 /* Process an SOI marker */
 {
  int i;
@@ -237,7 +237,7 @@ get_soi(j_decompress_ptr cinfo)


 LOCAL(boolean)
-get_sof(j_decompress_ptr cinfo, boolean is_prog, boolean is_arith)
+get_sof (j_decompress_ptr cinfo, boolean is_prog, boolean is_arith)
 /* Process a SOFn marker */
 {
  JLONG length;
@@ -258,7 +258,7 @@ get_sof(j_decompress_ptr cinfo, boolean is_prog, boolean is_arith)
  length -= 8;

  TRACEMS4(cinfo, 1, JTRC_SOF, cinfo->unread_marker,
-           (int)cinfo->image_width, (int)cinfo->image_height,
+           (int) cinfo->image_width, (int) cinfo->image_height,
           cinfo->num_components);

  if (cinfo->marker->saw_SOF)
@@ -267,16 +267,16 @@ get_sof(j_decompress_ptr cinfo, boolean is_prog, boolean is_arith)
  /* We don't support files in which the image height is initially specified */
  /* as 0 and is later redefined by DNL.  As long as we have to check that,  */
  /* might as well have a general sanity check. */
-  if (cinfo->image_height <= 0 || cinfo->image_width <= 0 ||
-      cinfo->num_components <= 0)
+  if (cinfo->image_height <= 0 || cinfo->image_width <= 0
+      || cinfo->num_components <= 0)
    ERREXIT(cinfo, JERR_EMPTY_IMAGE);

  if (length != (cinfo->num_components * 3))
    ERREXIT(cinfo, JERR_BAD_LENGTH);

  if (cinfo->comp_info == NULL) /* do only once, even if suspend */
-    cinfo->comp_info = (jpeg_component_info *)(*cinfo->mem->alloc_small)
-                        ((j_common_ptr)cinfo, JPOOL_IMAGE,
+    cinfo->comp_info = (jpeg_component_info *) (*cinfo->mem->alloc_small)
+                        ((j_common_ptr) cinfo, JPOOL_IMAGE,
                         cinfo->num_components * sizeof(jpeg_component_info));

  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
@@ -301,7 +301,7 @@ get_sof(j_decompress_ptr cinfo, boolean is_prog, boolean is_arith)


 LOCAL(boolean)
-get_sos(j_decompress_ptr cinfo)
+get_sos (j_decompress_ptr cinfo)
 /* Process a SOS marker */
 {
  JLONG length;
@@ -309,7 +309,7 @@ get_sos(j_decompress_ptr cinfo)
  jpeg_component_info *compptr;
  INPUT_VARS(cinfo);

-  if (!cinfo->marker->saw_SOF)
+  if (! cinfo->marker->saw_SOF)
    ERREXIT(cinfo, JERR_SOS_NO_SOF);

  INPUT_2BYTES(cinfo, length, return FALSE);
@@ -341,7 +341,7 @@ get_sos(j_decompress_ptr cinfo)

    ERREXIT1(cinfo, JERR_BAD_COMPONENT_ID, cc);

-id_found:
+  id_found:

    cinfo->cur_comp_info[i] = compptr;
    compptr->dc_tbl_no = (c >> 4) & 15;
@@ -384,7 +384,7 @@ id_found:
 #ifdef D_ARITH_CODING_SUPPORTED

 LOCAL(boolean)
-get_dac(j_decompress_ptr cinfo)
+get_dac (j_decompress_ptr cinfo)
 /* Process a DAC marker */
 {
  JLONG length;
@@ -402,14 +402,14 @@ get_dac(j_decompress_ptr cinfo)

    TRACEMS2(cinfo, 1, JTRC_DAC, index, val);

-    if (index < 0 || index >= (2 * NUM_ARITH_TBLS))
+    if (index < 0 || index >= (2*NUM_ARITH_TBLS))
      ERREXIT1(cinfo, JERR_DAC_INDEX, index);

    if (index >= NUM_ARITH_TBLS) { /* define AC table */
-      cinfo->arith_ac_K[index - NUM_ARITH_TBLS] = (UINT8)val;
+      cinfo->arith_ac_K[index-NUM_ARITH_TBLS] = (UINT8) val;
    } else {                    /* define DC table */
-      cinfo->arith_dc_L[index] = (UINT8)(val & 0x0F);
-      cinfo->arith_dc_U[index] = (UINT8)(val >> 4);
+      cinfo->arith_dc_L[index] = (UINT8) (val & 0x0F);
+      cinfo->arith_dc_U[index] = (UINT8) (val >> 4);
      if (cinfo->arith_dc_L[index] > cinfo->arith_dc_U[index])
        ERREXIT1(cinfo, JERR_DAC_VALUE, val);
    }
@@ -422,7 +422,7 @@ get_dac(j_decompress_ptr cinfo)
  return TRUE;
 }

-#else /* !D_ARITH_CODING_SUPPORTED */
+#else /* ! D_ARITH_CODING_SUPPORTED */

 #define get_dac(cinfo)  skip_variable(cinfo)

@@ -430,7 +430,7 @@ get_dac(j_decompress_ptr cinfo)


 LOCAL(boolean)
-get_dht(j_decompress_ptr cinfo)
+get_dht (j_decompress_ptr cinfo)
 /* Process a DHT marker */
 {
  JLONG length;
@@ -467,7 +467,7 @@ get_dht(j_decompress_ptr cinfo)
    /* Here we just do minimal validation of the counts to avoid walking
     * off the end of our table space.  jdhuff.c will check more carefully.
     */
-    if (count > 256 || ((JLONG)count) > length)
+    if (count > 256 || ((JLONG) count) > length)
      ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);

    for (i = 0; i < count; i++)
@@ -489,7 +489,7 @@ get_dht(j_decompress_ptr cinfo)
    }

    if (*htblptr == NULL)
-      *htblptr = jpeg_alloc_huff_table((j_common_ptr)cinfo);
+      *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);

    MEMCOPY((*htblptr)->bits, bits, sizeof((*htblptr)->bits));
    MEMCOPY((*htblptr)->huffval, huffval, sizeof((*htblptr)->huffval));
@@ -504,7 +504,7 @@ get_dht(j_decompress_ptr cinfo)


 LOCAL(boolean)
-get_dqt(j_decompress_ptr cinfo)
+get_dqt (j_decompress_ptr cinfo)
 /* Process a DQT marker */
 {
  JLONG length;
@@ -527,7 +527,7 @@ get_dqt(j_decompress_ptr cinfo)
      ERREXIT1(cinfo, JERR_DQT_INDEX, n);

    if (cinfo->quant_tbl_ptrs[n] == NULL)
-      cinfo->quant_tbl_ptrs[n] = jpeg_alloc_quant_table((j_common_ptr)cinfo);
+      cinfo->quant_tbl_ptrs[n] = jpeg_alloc_quant_table((j_common_ptr) cinfo);
    quant_ptr = cinfo->quant_tbl_ptrs[n];

    for (i = 0; i < DCTSIZE2; i++) {
@@ -536,20 +536,20 @@ get_dqt(j_decompress_ptr cinfo)
      else
        INPUT_BYTE(cinfo, tmp, return FALSE);
      /* We convert the zigzag-order table to natural array order. */
-      quant_ptr->quantval[jpeg_natural_order[i]] = (UINT16)tmp;
+      quant_ptr->quantval[jpeg_natural_order[i]] = (UINT16) tmp;
    }

    if (cinfo->err->trace_level >= 2) {
      for (i = 0; i < DCTSIZE2; i += 8) {
        TRACEMS8(cinfo, 2, JTRC_QUANTVALS,
-                 quant_ptr->quantval[i],     quant_ptr->quantval[i + 1],
-                 quant_ptr->quantval[i + 2], quant_ptr->quantval[i + 3],
-                 quant_ptr->quantval[i + 4], quant_ptr->quantval[i + 5],
-                 quant_ptr->quantval[i + 6], quant_ptr->quantval[i + 7]);
+                 quant_ptr->quantval[i],   quant_ptr->quantval[i+1],
+                 quant_ptr->quantval[i+2], quant_ptr->quantval[i+3],
+                 quant_ptr->quantval[i+4], quant_ptr->quantval[i+5],
+                 quant_ptr->quantval[i+6], quant_ptr->quantval[i+7]);
      }
    }

-    length -= DCTSIZE2 + 1;
+    length -= DCTSIZE2+1;
    if (prec) length -= DCTSIZE2;
  }

@@ -562,7 +562,7 @@ get_dqt(j_decompress_ptr cinfo)


 LOCAL(boolean)
-get_dri(j_decompress_ptr cinfo)
+get_dri (j_decompress_ptr cinfo)
 /* Process a DRI marker */
 {
  JLONG length;
@@ -598,28 +598,28 @@ get_dri(j_decompress_ptr cinfo)


 LOCAL(void)
-examine_app0(j_decompress_ptr cinfo, JOCTET *data, unsigned int datalen,
-             JLONG remaining)
+examine_app0 (j_decompress_ptr cinfo, JOCTET *data,
+              unsigned int datalen, JLONG remaining)
 /* Examine first few bytes from an APP0.
 * Take appropriate action if it is a JFIF marker.
 * datalen is # of bytes at data[], remaining is length of rest of marker data.
 */
 {
-  JLONG totallen = (JLONG)datalen + remaining;
+  JLONG totallen = (JLONG) datalen + remaining;

  if (datalen >= APP0_DATA_LEN &&
-      data[0] == 0x4A &&
-      data[1] == 0x46 &&
-      data[2] == 0x49 &&
-      data[3] == 0x46 &&
-      data[4] == 0) {
+      GETJOCTET(data[0]) == 0x4A &&
+      GETJOCTET(data[1]) == 0x46 &&
+      GETJOCTET(data[2]) == 0x49 &&
+      GETJOCTET(data[3]) == 0x46 &&
+      GETJOCTET(data[4]) == 0) {
    /* Found JFIF APP0 marker: save info */
    cinfo->saw_JFIF_marker = TRUE;
-    cinfo->JFIF_major_version = data[5];
-    cinfo->JFIF_minor_version = data[6];
-    cinfo->density_unit = data[7];
-    cinfo->X_density = (data[8] << 8) + data[9];
-    cinfo->Y_density = (data[10] << 8) + data[11];
+    cinfo->JFIF_major_version = GETJOCTET(data[5]);
+    cinfo->JFIF_minor_version = GETJOCTET(data[6]);
+    cinfo->density_unit = GETJOCTET(data[7]);
+    cinfo->X_density = (GETJOCTET(data[8]) << 8) + GETJOCTET(data[9]);
+    cinfo->Y_density = (GETJOCTET(data[10]) << 8) + GETJOCTET(data[11]);
    /* Check version.
     * Major version must be 1, anything else signals an incompatible change.
     * (We used to treat this as an error, but now it's a nonfatal warning,
@@ -634,45 +634,48 @@ examine_app0(j_decompress_ptr cinfo, JOCTET *data, unsigned int datalen,
             cinfo->JFIF_major_version, cinfo->JFIF_minor_version,
             cinfo->X_density, cinfo->Y_density, cinfo->density_unit);
    /* Validate thumbnail dimensions and issue appropriate messages */
-    if (data[12] | data[13])
-      TRACEMS2(cinfo, 1, JTRC_JFIF_THUMBNAIL, data[12], data[13]);
+    if (GETJOCTET(data[12]) | GETJOCTET(data[13]))
+      TRACEMS2(cinfo, 1, JTRC_JFIF_THUMBNAIL,
+               GETJOCTET(data[12]), GETJOCTET(data[13]));
    totallen -= APP0_DATA_LEN;
-    if (totallen != ((JLONG)data[12] * (JLONG)data[13] * (JLONG)3))
-      TRACEMS1(cinfo, 1, JTRC_JFIF_BADTHUMBNAILSIZE, (int)totallen);
+    if (totallen !=
+        ((JLONG)GETJOCTET(data[12]) * (JLONG)GETJOCTET(data[13]) * (JLONG) 3))
+      TRACEMS1(cinfo, 1, JTRC_JFIF_BADTHUMBNAILSIZE, (int) totallen);
  } else if (datalen >= 6 &&
-             data[0] == 0x4A &&
-             data[1] == 0x46 &&
-             data[2] == 0x58 &&
-             data[3] == 0x58 &&
-             data[4] == 0) {
+      GETJOCTET(data[0]) == 0x4A &&
+      GETJOCTET(data[1]) == 0x46 &&
+      GETJOCTET(data[2]) == 0x58 &&
+      GETJOCTET(data[3]) == 0x58 &&
+      GETJOCTET(data[4]) == 0) {
    /* Found JFIF "JFXX" extension APP0 marker */
    /* The library doesn't actually do anything with these,
     * but we try to produce a helpful trace message.
     */
-    switch (data[5]) {
+    switch (GETJOCTET(data[5])) {
    case 0x10:
-      TRACEMS1(cinfo, 1, JTRC_THUMB_JPEG, (int)totallen);
+      TRACEMS1(cinfo, 1, JTRC_THUMB_JPEG, (int) totallen);
      break;
    case 0x11:
-      TRACEMS1(cinfo, 1, JTRC_THUMB_PALETTE, (int)totallen);
+      TRACEMS1(cinfo, 1, JTRC_THUMB_PALETTE, (int) totallen);
      break;
    case 0x13:
-      TRACEMS1(cinfo, 1, JTRC_THUMB_RGB, (int)totallen);
+      TRACEMS1(cinfo, 1, JTRC_THUMB_RGB, (int) totallen);
      break;
    default:
-      TRACEMS2(cinfo, 1, JTRC_JFIF_EXTENSION, data[5], (int)totallen);
+      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 */
-    TRACEMS1(cinfo, 1, JTRC_APP0, (int)totallen);
+    TRACEMS1(cinfo, 1, JTRC_APP0, (int) totallen);
  }
 }


 LOCAL(void)
-examine_app14(j_decompress_ptr cinfo, JOCTET *data, unsigned int datalen,
-              JLONG remaining)
+examine_app14 (j_decompress_ptr cinfo, JOCTET *data,
+               unsigned int datalen, JLONG remaining)
 /* Examine first few bytes from an APP14.
 * Take appropriate action if it is an Adobe marker.
 * datalen is # of bytes at data[], remaining is length of rest of marker data.
@@ -681,28 +684,28 @@ examine_app14(j_decompress_ptr cinfo, JOCTET *data, unsigned int datalen,
  unsigned int version, flags0, flags1, transform;

  if (datalen >= APP14_DATA_LEN &&
-      data[0] == 0x41 &&
-      data[1] == 0x64 &&
-      data[2] == 0x6F &&
-      data[3] == 0x62 &&
-      data[4] == 0x65) {
+      GETJOCTET(data[0]) == 0x41 &&
+      GETJOCTET(data[1]) == 0x64 &&
+      GETJOCTET(data[2]) == 0x6F &&
+      GETJOCTET(data[3]) == 0x62 &&
+      GETJOCTET(data[4]) == 0x65) {
    /* Found Adobe APP14 marker */
-    version = (data[5] << 8) + data[6];
-    flags0 = (data[7] << 8) + data[8];
-    flags1 = (data[9] << 8) + data[10];
-    transform = data[11];
+    version = (GETJOCTET(data[5]) << 8) + GETJOCTET(data[6]);
+    flags0 = (GETJOCTET(data[7]) << 8) + GETJOCTET(data[8]);
+    flags1 = (GETJOCTET(data[9]) << 8) + GETJOCTET(data[10]);
+    transform = GETJOCTET(data[11]);
    TRACEMS4(cinfo, 1, JTRC_ADOBE, version, flags0, flags1, transform);
    cinfo->saw_Adobe_marker = TRUE;
-    cinfo->Adobe_transform = (UINT8)transform;
+    cinfo->Adobe_transform = (UINT8) transform;
  } else {
    /* Start of APP14 does not match "Adobe", or too short */
-    TRACEMS1(cinfo, 1, JTRC_APP14, (int)(datalen + remaining));
+    TRACEMS1(cinfo, 1, JTRC_APP14, (int) (datalen + remaining));
  }
 }


 METHODDEF(boolean)
-get_interesting_appn(j_decompress_ptr cinfo)
+get_interesting_appn (j_decompress_ptr cinfo)
 /* Process an APP0 or APP14 marker without saving it */
 {
  JLONG length;
@@ -717,7 +720,7 @@ get_interesting_appn(j_decompress_ptr cinfo)
  if (length >= APPN_DATA_LEN)
    numtoread = APPN_DATA_LEN;
  else if (length > 0)
-    numtoread = (unsigned int)length;
+    numtoread = (unsigned int) length;
  else
    numtoread = 0;
  for (i = 0; i < numtoread; i++)
@@ -727,10 +730,10 @@ get_interesting_appn(j_decompress_ptr cinfo)
  /* process it */
  switch (cinfo->unread_marker) {
  case M_APP0:
-    examine_app0(cinfo, (JOCTET *)b, numtoread, length);
+    examine_app0(cinfo, (JOCTET *) b, numtoread, length);
    break;
  case M_APP14:
-    examine_app14(cinfo, (JOCTET *)b, numtoread, length);
+    examine_app14(cinfo, (JOCTET *) b, numtoread, length);
    break;
  default:
    /* can't get here unless jpeg_save_markers chooses wrong processor */
@@ -741,7 +744,7 @@ get_interesting_appn(j_decompress_ptr cinfo)
  /* skip any remaining data -- could be lots */
  INPUT_SYNC(cinfo);
  if (length > 0)
-    (*cinfo->src->skip_input_data) (cinfo, (long)length);
+    (*cinfo->src->skip_input_data) (cinfo, (long) length);

  return TRUE;
 }
@@ -750,10 +753,10 @@ get_interesting_appn(j_decompress_ptr cinfo)
 #ifdef SAVE_MARKERS_SUPPORTED

 METHODDEF(boolean)
-save_marker(j_decompress_ptr cinfo)
+save_marker (j_decompress_ptr cinfo)
 /* Save an APPn or COM marker into the marker list */
 {
-  my_marker_ptr marker = (my_marker_ptr)cinfo->marker;
+  my_marker_ptr marker = (my_marker_ptr) cinfo->marker;
  jpeg_saved_marker_ptr cur_marker = marker->cur_marker;
  unsigned int bytes_read, data_length;
  JOCTET *data;
@@ -767,22 +770,22 @@ save_marker(j_decompress_ptr cinfo)
    if (length >= 0) {          /* watch out for bogus length word */
      /* figure out how much we want to save */
      unsigned int limit;
-      if (cinfo->unread_marker == (int)M_COM)
+      if (cinfo->unread_marker == (int) M_COM)
        limit = marker->length_limit_COM;
      else
-        limit = marker->length_limit_APPn[cinfo->unread_marker - (int)M_APP0];
-      if ((unsigned int)length < limit)
-        limit = (unsigned int)length;
+        limit = marker->length_limit_APPn[cinfo->unread_marker - (int) M_APP0];
+      if ((unsigned int) length < limit)
+        limit = (unsigned int) length;
      /* allocate and initialize the marker item */
      cur_marker = (jpeg_saved_marker_ptr)
-        (*cinfo->mem->alloc_large) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+        (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                    sizeof(struct jpeg_marker_struct) + limit);
      cur_marker->next = NULL;
-      cur_marker->marker = (UINT8)cinfo->unread_marker;
-      cur_marker->original_length = (unsigned int)length;
+      cur_marker->marker = (UINT8) cinfo->unread_marker;
+      cur_marker->original_length = (unsigned int) length;
      cur_marker->data_length = limit;
      /* data area is just beyond the jpeg_marker_struct */
-      data = cur_marker->data = (JOCTET *)(cur_marker + 1);
+      data = cur_marker->data = (JOCTET *) (cur_marker + 1);
      marker->cur_marker = cur_marker;
      marker->bytes_read = 0;
      bytes_read = 0;
@@ -840,14 +843,14 @@ save_marker(j_decompress_ptr cinfo)
    break;
  default:
    TRACEMS2(cinfo, 1, JTRC_MISC_MARKER, cinfo->unread_marker,
-             (int)(data_length + length));
+             (int) (data_length + length));
    break;
  }

  /* skip any remaining data -- could be lots */
  INPUT_SYNC(cinfo);            /* do before skip_input_data */
  if (length > 0)
-    (*cinfo->src->skip_input_data) (cinfo, (long)length);
+    (*cinfo->src->skip_input_data) (cinfo, (long) length);

  return TRUE;
 }
@@ -856,7 +859,7 @@ save_marker(j_decompress_ptr cinfo)


 METHODDEF(boolean)
-skip_variable(j_decompress_ptr cinfo)
+skip_variable (j_decompress_ptr cinfo)
 /* Skip over an unknown or uninteresting variable-length marker */
 {
  JLONG length;
@@ -865,11 +868,11 @@ skip_variable(j_decompress_ptr cinfo)
  INPUT_2BYTES(cinfo, length, return FALSE);
  length -= 2;

-  TRACEMS2(cinfo, 1, JTRC_MISC_MARKER, cinfo->unread_marker, (int)length);
+  TRACEMS2(cinfo, 1, JTRC_MISC_MARKER, cinfo->unread_marker, (int) length);

  INPUT_SYNC(cinfo);            /* do before skip_input_data */
  if (length > 0)
-    (*cinfo->src->skip_input_data) (cinfo, (long)length);
+    (*cinfo->src->skip_input_data) (cinfo, (long) length);

  return TRUE;
 }
@@ -885,7 +888,7 @@ skip_variable(j_decompress_ptr cinfo)
 */

 LOCAL(boolean)
-next_marker(j_decompress_ptr cinfo)
+next_marker (j_decompress_ptr cinfo)
 {
  int c;
  INPUT_VARS(cinfo);
@@ -932,7 +935,7 @@ next_marker(j_decompress_ptr cinfo)


 LOCAL(boolean)
-first_marker(j_decompress_ptr cinfo)
+first_marker (j_decompress_ptr cinfo)
 /* Like next_marker, but used to obtain the initial SOI marker. */
 /* For this marker, we do not allow preceding garbage or fill; otherwise,
 * we might well scan an entire input file before realizing it ain't JPEG.
@@ -945,7 +948,7 @@ first_marker(j_decompress_ptr cinfo)

  INPUT_BYTE(cinfo, c, return FALSE);
  INPUT_BYTE(cinfo, c2, return FALSE);
-  if (c != 0xFF || c2 != (int)M_SOI)
+  if (c != 0xFF || c2 != (int) M_SOI)
    ERREXIT2(cinfo, JERR_NO_SOI, c, c2);

  cinfo->unread_marker = c2;
@@ -963,18 +966,18 @@ first_marker(j_decompress_ptr cinfo)
 */

 METHODDEF(int)
-read_markers(j_decompress_ptr cinfo)
+read_markers (j_decompress_ptr cinfo)
 {
  /* Outer loop repeats once for each marker. */
  for (;;) {
    /* Collect the marker proper, unless we already did. */
    /* NB: first_marker() enforces the requirement that SOI appear first. */
    if (cinfo->unread_marker == 0) {
-      if (!cinfo->marker->saw_SOI) {
-        if (!first_marker(cinfo))
+      if (! cinfo->marker->saw_SOI) {
+        if (! first_marker(cinfo))
          return JPEG_SUSPENDED;
      } else {
-        if (!next_marker(cinfo))
+        if (! next_marker(cinfo))
          return JPEG_SUSPENDED;
      }
    }
@@ -984,28 +987,28 @@ read_markers(j_decompress_ptr cinfo)
     */
    switch (cinfo->unread_marker) {
    case M_SOI:
-      if (!get_soi(cinfo))
+      if (! get_soi(cinfo))
        return JPEG_SUSPENDED;
      break;

    case M_SOF0:                /* Baseline */
    case M_SOF1:                /* Extended sequential, Huffman */
-      if (!get_sof(cinfo, FALSE, FALSE))
+      if (! get_sof(cinfo, FALSE, FALSE))
        return JPEG_SUSPENDED;
      break;

    case M_SOF2:                /* Progressive, Huffman */
-      if (!get_sof(cinfo, TRUE, FALSE))
+      if (! get_sof(cinfo, TRUE, FALSE))
        return JPEG_SUSPENDED;
      break;

    case M_SOF9:                /* Extended sequential, arithmetic */
-      if (!get_sof(cinfo, FALSE, TRUE))
+      if (! get_sof(cinfo, FALSE, TRUE))
        return JPEG_SUSPENDED;
      break;

    case M_SOF10:               /* Progressive, arithmetic */
-      if (!get_sof(cinfo, TRUE, TRUE))
+      if (! get_sof(cinfo, TRUE, TRUE))
        return JPEG_SUSPENDED;
      break;

@@ -1023,7 +1026,7 @@ read_markers(j_decompress_ptr cinfo)
      break;

    case M_SOS:
-      if (!get_sos(cinfo))
+      if (! get_sos(cinfo))
        return JPEG_SUSPENDED;
      cinfo->unread_marker = 0; /* processed the marker */
      return JPEG_REACHED_SOS;
@@ -1034,22 +1037,22 @@ read_markers(j_decompress_ptr cinfo)
      return JPEG_REACHED_EOI;

    case M_DAC:
-      if (!get_dac(cinfo))
+      if (! get_dac(cinfo))
        return JPEG_SUSPENDED;
      break;

    case M_DHT:
-      if (!get_dht(cinfo))
+      if (! get_dht(cinfo))
        return JPEG_SUSPENDED;
      break;

    case M_DQT:
-      if (!get_dqt(cinfo))
+      if (! get_dqt(cinfo))
        return JPEG_SUSPENDED;
      break;

    case M_DRI:
-      if (!get_dri(cinfo))
+      if (! get_dri(cinfo))
        return JPEG_SUSPENDED;
      break;

@@ -1069,13 +1072,13 @@ read_markers(j_decompress_ptr cinfo)
    case M_APP13:
    case M_APP14:
    case M_APP15:
-      if (!(*((my_marker_ptr)cinfo->marker)->process_APPn[
-               cinfo->unread_marker - (int)M_APP0]) (cinfo))
+      if (! (*((my_marker_ptr) cinfo->marker)->process_APPn[
+                cinfo->unread_marker - (int) M_APP0]) (cinfo))
        return JPEG_SUSPENDED;
      break;

    case M_COM:
-      if (!(*((my_marker_ptr)cinfo->marker)->process_COM) (cinfo))
+      if (! (*((my_marker_ptr) cinfo->marker)->process_COM) (cinfo))
        return JPEG_SUSPENDED;
      break;

@@ -1092,7 +1095,7 @@ read_markers(j_decompress_ptr cinfo)
      break;

    case M_DNL:                 /* Ignore DNL ... perhaps the wrong thing */
-      if (!skip_variable(cinfo))
+      if (! skip_variable(cinfo))
        return JPEG_SUSPENDED;
      break;

@@ -1124,25 +1127,25 @@ read_markers(j_decompress_ptr cinfo)
 */

 METHODDEF(boolean)
-read_restart_marker(j_decompress_ptr cinfo)
+read_restart_marker (j_decompress_ptr cinfo)
 {
  /* Obtain a marker unless we already did. */
  /* Note that next_marker will complain if it skips any data. */
  if (cinfo->unread_marker == 0) {
-    if (!next_marker(cinfo))
+    if (! next_marker(cinfo))
      return FALSE;
  }

  if (cinfo->unread_marker ==
-      ((int)M_RST0 + cinfo->marker->next_restart_num)) {
+      ((int) M_RST0 + cinfo->marker->next_restart_num)) {
    /* Normal case --- swallow the marker and let entropy decoder continue */
    TRACEMS1(cinfo, 3, JTRC_RST, cinfo->marker->next_restart_num);
    cinfo->unread_marker = 0;
  } else {
    /* Uh-oh, the restart markers have been messed up. */
    /* Let the data source manager determine how to resync. */
-    if (!(*cinfo->src->resync_to_restart) (cinfo,
-                                           cinfo->marker->next_restart_num))
+    if (! (*cinfo->src->resync_to_restart) (cinfo,
+                                            cinfo->marker->next_restart_num))
      return FALSE;
  }

@@ -1203,7 +1206,7 @@ read_restart_marker(j_decompress_ptr cinfo)
 */

 GLOBAL(boolean)
-jpeg_resync_to_restart(j_decompress_ptr cinfo, int desired)
+jpeg_resync_to_restart (j_decompress_ptr cinfo, int desired)
 {
  int marker = cinfo->unread_marker;
  int action = 1;
@@ -1213,16 +1216,16 @@ jpeg_resync_to_restart(j_decompress_ptr cinfo, int desired)

  /* Outer loop handles repeated decision after scanning forward. */
  for (;;) {
-    if (marker < (int)M_SOF0)
+    if (marker < (int) M_SOF0)
      action = 2;               /* invalid marker */
-    else if (marker < (int)M_RST0 || marker > (int)M_RST7)
+    else if (marker < (int) M_RST0 || marker > (int) M_RST7)
      action = 3;               /* valid non-restart marker */
    else {
-      if (marker == ((int)M_RST0 + ((desired + 1) & 7)) ||
-          marker == ((int)M_RST0 + ((desired + 2) & 7)))
+      if (marker == ((int) M_RST0 + ((desired+1) & 7)) ||
+          marker == ((int) M_RST0 + ((desired+2) & 7)))
        action = 3;             /* one of the next two expected restarts */
-      else if (marker == ((int)M_RST0 + ((desired - 1) & 7)) ||
-               marker == ((int)M_RST0 + ((desired - 2) & 7)))
+      else if (marker == ((int) M_RST0 + ((desired-1) & 7)) ||
+               marker == ((int) M_RST0 + ((desired-2) & 7)))
        action = 2;             /* a prior restart, so advance */
      else
        action = 1;             /* desired restart or too far away */
@@ -1235,7 +1238,7 @@ jpeg_resync_to_restart(j_decompress_ptr cinfo, int desired)
      return TRUE;
    case 2:
      /* Scan to the next marker, and repeat the decision loop. */
-      if (!next_marker(cinfo))
+      if (! next_marker(cinfo))
        return FALSE;
      marker = cinfo->unread_marker;
      break;
@@ -1253,9 +1256,9 @@ jpeg_resync_to_restart(j_decompress_ptr cinfo, int desired)
 */

 METHODDEF(void)
-reset_marker_reader(j_decompress_ptr cinfo)
+reset_marker_reader (j_decompress_ptr cinfo)
 {
-  my_marker_ptr marker = (my_marker_ptr)cinfo->marker;
+  my_marker_ptr marker = (my_marker_ptr) cinfo->marker;

  cinfo->comp_info = NULL;              /* until allocated by get_sof */
  cinfo->input_scan_number = 0;         /* no SOS seen yet */
@@ -1273,16 +1276,16 @@ reset_marker_reader(j_decompress_ptr cinfo)
 */

 GLOBAL(void)
-jinit_marker_reader(j_decompress_ptr cinfo)
+jinit_marker_reader (j_decompress_ptr cinfo)
 {
  my_marker_ptr marker;
  int i;

  /* Create subobject in permanent pool */
  marker = (my_marker_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
                                sizeof(my_marker_reader));
-  cinfo->marker = (struct jpeg_marker_reader *)marker;
+  cinfo->marker = (struct jpeg_marker_reader *) marker;
  /* Initialize public method pointers */
  marker->pub.reset_marker_reader = reset_marker_reader;
  marker->pub.read_markers = read_markers;
@@ -1311,10 +1314,10 @@ jinit_marker_reader(j_decompress_ptr cinfo)
 #ifdef SAVE_MARKERS_SUPPORTED

 GLOBAL(void)
-jpeg_save_markers(j_decompress_ptr cinfo, int marker_code,
-                  unsigned int length_limit)
+jpeg_save_markers (j_decompress_ptr cinfo, int marker_code,
+                   unsigned int length_limit)
 {
-  my_marker_ptr marker = (my_marker_ptr)cinfo->marker;
+  my_marker_ptr marker = (my_marker_ptr) cinfo->marker;
  long maxlength;
  jpeg_marker_parser_method processor;

@@ -1322,8 +1325,8 @@ jpeg_save_markers(j_decompress_ptr cinfo, int marker_code,
   * (should only be a concern in a 16-bit environment).
   */
  maxlength = cinfo->mem->max_alloc_chunk - sizeof(struct jpeg_marker_struct);
-  if (((long)length_limit) > maxlength)
-    length_limit = (unsigned int)maxlength;
+  if (((long) length_limit) > maxlength)
+    length_limit = (unsigned int) maxlength;

  /* Choose processor routine to use.
   * APP0/APP14 have special requirements.
@@ -1331,23 +1334,23 @@ jpeg_save_markers(j_decompress_ptr cinfo, int marker_code,
  if (length_limit) {
    processor = save_marker;
    /* If saving APP0/APP14, save at least enough for our internal use. */
-    if (marker_code == (int)M_APP0 && length_limit < APP0_DATA_LEN)
+    if (marker_code == (int) M_APP0 && length_limit < APP0_DATA_LEN)
      length_limit = APP0_DATA_LEN;
-    else if (marker_code == (int)M_APP14 && length_limit < APP14_DATA_LEN)
+    else if (marker_code == (int) M_APP14 && length_limit < APP14_DATA_LEN)
      length_limit = APP14_DATA_LEN;
  } else {
    processor = skip_variable;
    /* If discarding APP0/APP14, use our regular on-the-fly processor. */
-    if (marker_code == (int)M_APP0 || marker_code == (int)M_APP14)
+    if (marker_code == (int) M_APP0 || marker_code == (int) M_APP14)
      processor = get_interesting_appn;
  }

-  if (marker_code == (int)M_COM) {
+  if (marker_code == (int) M_COM) {
    marker->process_COM = processor;
    marker->length_limit_COM = length_limit;
-  } else if (marker_code >= (int)M_APP0 && marker_code <= (int)M_APP15) {
-    marker->process_APPn[marker_code - (int)M_APP0] = processor;
-    marker->length_limit_APPn[marker_code - (int)M_APP0] = length_limit;
+  } else if (marker_code >= (int) M_APP0 && marker_code <= (int) M_APP15) {
+    marker->process_APPn[marker_code - (int) M_APP0] = processor;
+    marker->length_limit_APPn[marker_code - (int) M_APP0] = length_limit;
  } else
    ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, marker_code);
 }
@@ -1360,15 +1363,15 @@ jpeg_save_markers(j_decompress_ptr cinfo, int marker_code,
 */

 GLOBAL(void)
-jpeg_set_marker_processor(j_decompress_ptr cinfo, int marker_code,
-                          jpeg_marker_parser_method routine)
+jpeg_set_marker_processor (j_decompress_ptr cinfo, int marker_code,
+                           jpeg_marker_parser_method routine)
 {
-  my_marker_ptr marker = (my_marker_ptr)cinfo->marker;
+  my_marker_ptr marker = (my_marker_ptr) cinfo->marker;

-  if (marker_code == (int)M_COM)
+  if (marker_code == (int) M_COM)
    marker->process_COM = routine;
-  else if (marker_code >= (int)M_APP0 && marker_code <= (int)M_APP15)
-    marker->process_APPn[marker_code - (int)M_APP0] = routine;
+  else if (marker_code >= (int) M_APP0 && marker_code <= (int) M_APP15)
+    marker->process_APPn[marker_code - (int) M_APP0] = routine;
  else
    ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, marker_code);
 }
@@ -5,7 +5,7 @@
 * Copyright (C) 1991-1997, Thomas G. Lane.
 * Modified 2002-2009 by Guido Vollbeding.
 * libjpeg-turbo Modifications:
- * Copyright (C) 2009-2011, 2016, 2019, D. R. Commander.
+ * Copyright (C) 2009-2011, 2016, D. R. Commander.
 * Copyright (C) 2013, Linaro Limited.
 * Copyright (C) 2015, Google, Inc.
 * For conditions of distribution and use, see the accompanying README.ijg
@@ -22,6 +22,7 @@
 #include "jpeglib.h"
 #include "jpegcomp.h"
 #include "jdmaster.h"
+#include "jsimd.h"


 /*
@@ -30,7 +31,7 @@
 */

 LOCAL(boolean)
-use_merged_upsample(j_decompress_ptr cinfo)
+use_merged_upsample (j_decompress_ptr cinfo)
 {
 #ifdef UPSAMPLE_MERGING_SUPPORTED
  /* Merging is the equivalent of plain box-filter upsampling */
@@ -39,22 +40,22 @@ use_merged_upsample(j_decompress_ptr cinfo)
  /* jdmerge.c only supports YCC=>RGB and YCC=>RGB565 color conversion */
  if (cinfo->jpeg_color_space != JCS_YCbCr || cinfo->num_components != 3 ||
      (cinfo->out_color_space != JCS_RGB &&
-       cinfo->out_color_space != JCS_RGB565 &&
-       cinfo->out_color_space != JCS_EXT_RGB &&
-       cinfo->out_color_space != JCS_EXT_RGBX &&
-       cinfo->out_color_space != JCS_EXT_BGR &&
-       cinfo->out_color_space != JCS_EXT_BGRX &&
-       cinfo->out_color_space != JCS_EXT_XBGR &&
-       cinfo->out_color_space != JCS_EXT_XRGB &&
-       cinfo->out_color_space != JCS_EXT_RGBA &&
-       cinfo->out_color_space != JCS_EXT_BGRA &&
-       cinfo->out_color_space != JCS_EXT_ABGR &&
-       cinfo->out_color_space != JCS_EXT_ARGB))
+      cinfo->out_color_space != JCS_RGB565 &&
+      cinfo->out_color_space != JCS_EXT_RGB &&
+      cinfo->out_color_space != JCS_EXT_RGBX &&
+      cinfo->out_color_space != JCS_EXT_BGR &&
+      cinfo->out_color_space != JCS_EXT_BGRX &&
+      cinfo->out_color_space != JCS_EXT_XBGR &&
+      cinfo->out_color_space != JCS_EXT_XRGB &&
+      cinfo->out_color_space != JCS_EXT_RGBA &&
+      cinfo->out_color_space != JCS_EXT_BGRA &&
+      cinfo->out_color_space != JCS_EXT_ABGR &&
+      cinfo->out_color_space != JCS_EXT_ARGB))
    return FALSE;
  if ((cinfo->out_color_space == JCS_RGB565 &&
-       cinfo->out_color_components != 3) ||
+      cinfo->out_color_components != 3) ||
      (cinfo->out_color_space != JCS_RGB565 &&
-       cinfo->out_color_components != rgb_pixelsize[cinfo->out_color_space]))
+      cinfo->out_color_components != rgb_pixelsize[cinfo->out_color_space]))
    return FALSE;
  /* and it only handles 2h1v or 2h2v sampling ratios */
  if (cinfo->comp_info[0].h_samp_factor != 2 ||
@@ -69,6 +70,17 @@ use_merged_upsample(j_decompress_ptr cinfo)
      cinfo->comp_info[1]._DCT_scaled_size != cinfo->_min_DCT_scaled_size ||
      cinfo->comp_info[2]._DCT_scaled_size != cinfo->_min_DCT_scaled_size)
    return FALSE;
+#ifdef WITH_SIMD
+  /* If YCbCr-to-RGB color conversion is SIMD-accelerated but merged upsampling
+     isn't, then disabling merged upsampling is likely to be faster when
+     decompressing YCbCr JPEG images. */
+  if (!jsimd_can_h2v2_merged_upsample() && !jsimd_can_h2v1_merged_upsample() &&
+      jsimd_can_ycc_rgb() && cinfo->jpeg_color_space == JCS_YCbCr &&
+      (cinfo->out_color_space == JCS_RGB ||
+       (cinfo->out_color_space >= JCS_EXT_RGB &&
+        cinfo->out_color_space <= JCS_EXT_ARGB)))
+    return FALSE;
+#endif
  /* ??? also need to test for upsample-time rescaling, when & if supported */
  return TRUE;                  /* by golly, it'll work... */
 #else
@@ -88,7 +100,7 @@ GLOBAL(void)
 #else
 LOCAL(void)
 #endif
-jpeg_core_output_dimensions(j_decompress_ptr cinfo)
+jpeg_core_output_dimensions (j_decompress_ptr cinfo)
 /* Do computations that are needed before master selection phase.
 * This function is used for transcoding and full decompression.
 */
@@ -101,129 +113,129 @@ jpeg_core_output_dimensions(j_decompress_ptr cinfo)
  if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom) {
    /* Provide 1/block_size scaling */
    cinfo->output_width = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_width, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_width, (long) DCTSIZE);
    cinfo->output_height = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_height, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_height, (long) DCTSIZE);
    cinfo->_min_DCT_h_scaled_size = 1;
    cinfo->_min_DCT_v_scaled_size = 1;
  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 2) {
    /* Provide 2/block_size scaling */
    cinfo->output_width = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_width * 2L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_width * 2L, (long) DCTSIZE);
    cinfo->output_height = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_height * 2L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_height * 2L, (long) DCTSIZE);
    cinfo->_min_DCT_h_scaled_size = 2;
    cinfo->_min_DCT_v_scaled_size = 2;
  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 3) {
    /* Provide 3/block_size scaling */
    cinfo->output_width = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_width * 3L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_width * 3L, (long) DCTSIZE);
    cinfo->output_height = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_height * 3L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_height * 3L, (long) DCTSIZE);
    cinfo->_min_DCT_h_scaled_size = 3;
    cinfo->_min_DCT_v_scaled_size = 3;
  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 4) {
    /* Provide 4/block_size scaling */
    cinfo->output_width = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_width * 4L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_width * 4L, (long) DCTSIZE);
    cinfo->output_height = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_height * 4L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_height * 4L, (long) DCTSIZE);
    cinfo->_min_DCT_h_scaled_size = 4;
    cinfo->_min_DCT_v_scaled_size = 4;
  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 5) {
    /* Provide 5/block_size scaling */
    cinfo->output_width = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_width * 5L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_width * 5L, (long) DCTSIZE);
    cinfo->output_height = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_height * 5L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_height * 5L, (long) DCTSIZE);
    cinfo->_min_DCT_h_scaled_size = 5;
    cinfo->_min_DCT_v_scaled_size = 5;
  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 6) {
    /* Provide 6/block_size scaling */
    cinfo->output_width = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_width * 6L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_width * 6L, (long) DCTSIZE);
    cinfo->output_height = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_height * 6L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_height * 6L, (long) DCTSIZE);
    cinfo->_min_DCT_h_scaled_size = 6;
    cinfo->_min_DCT_v_scaled_size = 6;
  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 7) {
    /* Provide 7/block_size scaling */
    cinfo->output_width = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_width * 7L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_width * 7L, (long) DCTSIZE);
    cinfo->output_height = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_height * 7L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_height * 7L, (long) DCTSIZE);
    cinfo->_min_DCT_h_scaled_size = 7;
    cinfo->_min_DCT_v_scaled_size = 7;
  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 8) {
    /* Provide 8/block_size scaling */
    cinfo->output_width = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_width * 8L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_width * 8L, (long) DCTSIZE);
    cinfo->output_height = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_height * 8L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_height * 8L, (long) DCTSIZE);
    cinfo->_min_DCT_h_scaled_size = 8;
    cinfo->_min_DCT_v_scaled_size = 8;
  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 9) {
    /* Provide 9/block_size scaling */
    cinfo->output_width = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_width * 9L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_width * 9L, (long) DCTSIZE);
    cinfo->output_height = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_height * 9L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_height * 9L, (long) DCTSIZE);
    cinfo->_min_DCT_h_scaled_size = 9;
    cinfo->_min_DCT_v_scaled_size = 9;
  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 10) {
    /* Provide 10/block_size scaling */
    cinfo->output_width = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_width * 10L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_width * 10L, (long) DCTSIZE);
    cinfo->output_height = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_height * 10L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_height * 10L, (long) DCTSIZE);
    cinfo->_min_DCT_h_scaled_size = 10;
    cinfo->_min_DCT_v_scaled_size = 10;
  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 11) {
    /* Provide 11/block_size scaling */
    cinfo->output_width = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_width * 11L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_width * 11L, (long) DCTSIZE);
    cinfo->output_height = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_height * 11L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_height * 11L, (long) DCTSIZE);
    cinfo->_min_DCT_h_scaled_size = 11;
    cinfo->_min_DCT_v_scaled_size = 11;
  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 12) {
    /* Provide 12/block_size scaling */
    cinfo->output_width = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_width * 12L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_width * 12L, (long) DCTSIZE);
    cinfo->output_height = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_height * 12L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_height * 12L, (long) DCTSIZE);
    cinfo->_min_DCT_h_scaled_size = 12;
    cinfo->_min_DCT_v_scaled_size = 12;
  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 13) {
    /* Provide 13/block_size scaling */
    cinfo->output_width = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_width * 13L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_width * 13L, (long) DCTSIZE);
    cinfo->output_height = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_height * 13L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_height * 13L, (long) DCTSIZE);
    cinfo->_min_DCT_h_scaled_size = 13;
    cinfo->_min_DCT_v_scaled_size = 13;
  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 14) {
    /* Provide 14/block_size scaling */
    cinfo->output_width = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_width * 14L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_width * 14L, (long) DCTSIZE);
    cinfo->output_height = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_height * 14L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_height * 14L, (long) DCTSIZE);
    cinfo->_min_DCT_h_scaled_size = 14;
    cinfo->_min_DCT_v_scaled_size = 14;
  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 15) {
    /* Provide 15/block_size scaling */
    cinfo->output_width = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_width * 15L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_width * 15L, (long) DCTSIZE);
    cinfo->output_height = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_height * 15L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_height * 15L, (long) DCTSIZE);
    cinfo->_min_DCT_h_scaled_size = 15;
    cinfo->_min_DCT_v_scaled_size = 15;
  } else {
    /* Provide 16/block_size scaling */
    cinfo->output_width = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_width * 16L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_width * 16L, (long) DCTSIZE);
    cinfo->output_height = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_height * 16L, (long)DCTSIZE);
+      jdiv_round_up((long) cinfo->image_height * 16L, (long) DCTSIZE);
    cinfo->_min_DCT_h_scaled_size = 16;
    cinfo->_min_DCT_v_scaled_size = 16;
  }
@@ -256,7 +268,7 @@ jpeg_core_output_dimensions(j_decompress_ptr cinfo)
 */

 GLOBAL(void)
-jpeg_calc_output_dimensions(j_decompress_ptr cinfo)
+jpeg_calc_output_dimensions (j_decompress_ptr cinfo)
 /* Do computations that are needed before master selection phase */
 {
 #ifdef IDCT_SCALING_SUPPORTED
@@ -302,13 +314,13 @@ jpeg_calc_output_dimensions(j_decompress_ptr cinfo)
       ci++, compptr++) {
    /* Size in samples, after IDCT scaling */
    compptr->downsampled_width = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_width *
-                    (long)(compptr->h_samp_factor * compptr->_DCT_scaled_size),
-                    (long)(cinfo->max_h_samp_factor * DCTSIZE));
+      jdiv_round_up((long) cinfo->image_width *
+                    (long) (compptr->h_samp_factor * compptr->_DCT_scaled_size),
+                    (long) (cinfo->max_h_samp_factor * DCTSIZE));
    compptr->downsampled_height = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_height *
-                    (long)(compptr->v_samp_factor * compptr->_DCT_scaled_size),
-                    (long)(cinfo->max_v_samp_factor * DCTSIZE));
+      jdiv_round_up((long) cinfo->image_height *
+                    (long) (compptr->v_samp_factor * compptr->_DCT_scaled_size),
+                    (long) (cinfo->max_v_samp_factor * DCTSIZE));
  }

 #else /* !IDCT_SCALING_SUPPORTED */
@@ -405,30 +417,30 @@ jpeg_calc_output_dimensions(j_decompress_ptr cinfo)
 */

 LOCAL(void)
-prepare_range_limit_table(j_decompress_ptr cinfo)
+prepare_range_limit_table (j_decompress_ptr cinfo)
 /* Allocate and fill in the sample_range_limit table */
 {
  JSAMPLE *table;
  int i;

  table = (JSAMPLE *)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                (5 * (MAXJSAMPLE + 1) + CENTERJSAMPLE) * sizeof(JSAMPLE));
-  table += (MAXJSAMPLE + 1);    /* allow negative subscripts of simple table */
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+                (5 * (MAXJSAMPLE+1) + CENTERJSAMPLE) * sizeof(JSAMPLE));
+  table += (MAXJSAMPLE+1);      /* allow negative subscripts of simple table */
  cinfo->sample_range_limit = table;
  /* First segment of "simple" table: limit[x] = 0 for x < 0 */
-  MEMZERO(table - (MAXJSAMPLE + 1), (MAXJSAMPLE + 1) * sizeof(JSAMPLE));
+  MEMZERO(table - (MAXJSAMPLE+1), (MAXJSAMPLE+1) * sizeof(JSAMPLE));
  /* Main part of "simple" table: limit[x] = x */
  for (i = 0; i <= MAXJSAMPLE; i++)
-    table[i] = (JSAMPLE)i;
+    table[i] = (JSAMPLE) i;
  table += CENTERJSAMPLE;       /* Point to where post-IDCT table starts */
  /* End of simple table, rest of first half of post-IDCT table */
-  for (i = CENTERJSAMPLE; i < 2 * (MAXJSAMPLE + 1); i++)
+  for (i = CENTERJSAMPLE; i < 2*(MAXJSAMPLE+1); i++)
    table[i] = MAXJSAMPLE;
  /* Second half of post-IDCT table */
-  MEMZERO(table + (2 * (MAXJSAMPLE + 1)),
-          (2 * (MAXJSAMPLE + 1) - CENTERJSAMPLE) * sizeof(JSAMPLE));
-  MEMCOPY(table + (4 * (MAXJSAMPLE + 1) - CENTERJSAMPLE),
+  MEMZERO(table + (2 * (MAXJSAMPLE+1)),
+          (2 * (MAXJSAMPLE+1) - CENTERJSAMPLE) * sizeof(JSAMPLE));
+  MEMCOPY(table + (4 * (MAXJSAMPLE+1) - CENTERJSAMPLE),
          cinfo->sample_range_limit, CENTERJSAMPLE * sizeof(JSAMPLE));
 }

@@ -445,9 +457,9 @@ prepare_range_limit_table(j_decompress_ptr cinfo)
 */

 LOCAL(void)
-master_selection(j_decompress_ptr cinfo)
+master_selection (j_decompress_ptr cinfo)
 {
-  my_master_ptr master = (my_master_ptr)cinfo->master;
+  my_master_ptr master = (my_master_ptr) cinfo->master;
  boolean use_c_buffer;
  long samplesperrow;
  JDIMENSION jd_samplesperrow;
@@ -457,10 +469,9 @@ master_selection(j_decompress_ptr cinfo)
  prepare_range_limit_table(cinfo);

  /* Width of an output scanline must be representable as JDIMENSION. */
-  samplesperrow = (long)cinfo->output_width *
-                  (long)cinfo->out_color_components;
-  jd_samplesperrow = (JDIMENSION)samplesperrow;
-  if ((long)jd_samplesperrow != samplesperrow)
+  samplesperrow = (long) cinfo->output_width * (long) cinfo->out_color_components;
+  jd_samplesperrow = (JDIMENSION) samplesperrow;
+  if ((long) jd_samplesperrow != samplesperrow)
    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);

  /* Initialize my private state */
@@ -471,7 +482,7 @@ master_selection(j_decompress_ptr cinfo)
  master->quantizer_1pass = NULL;
  master->quantizer_2pass = NULL;
  /* No mode changes if not using buffered-image mode. */
-  if (!cinfo->quantize_colors || !cinfo->buffered_image) {
+  if (! cinfo->quantize_colors || ! cinfo->buffered_image) {
    cinfo->enable_1pass_quant = FALSE;
    cinfo->enable_external_quant = FALSE;
    cinfo->enable_2pass_quant = FALSE;
@@ -517,7 +528,7 @@ master_selection(j_decompress_ptr cinfo)
  }

  /* Post-processing: in particular, color conversion first */
-  if (!cinfo->raw_data_out) {
+  if (! cinfo->raw_data_out) {
    if (master->using_merged_upsample) {
 #ifdef UPSAMPLE_MERGING_SUPPORTED
      jinit_merged_upsampler(cinfo); /* does color conversion too */
@@ -554,11 +565,11 @@ master_selection(j_decompress_ptr cinfo)
  use_c_buffer = cinfo->inputctl->has_multiple_scans || cinfo->buffered_image;
  jinit_d_coef_controller(cinfo, use_c_buffer);

-  if (!cinfo->raw_data_out)
+  if (! cinfo->raw_data_out)
    jinit_d_main_controller(cinfo, FALSE /* never need full buffer here */);

  /* We can now tell the memory manager to allocate virtual arrays. */
-  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr)cinfo);
+  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);

  /* Initialize input side of decompressor to consume first scan. */
  (*cinfo->inputctl->start_input_pass) (cinfo);
@@ -568,14 +579,13 @@ master_selection(j_decompress_ptr cinfo)
   */
  cinfo->master->first_iMCU_col = 0;
  cinfo->master->last_iMCU_col = cinfo->MCUs_per_row - 1;
-  cinfo->master->last_good_iMCU_row = 0;

 #ifdef D_MULTISCAN_FILES_SUPPORTED
  /* If jpeg_start_decompress will read the whole file, initialize
   * progress monitoring appropriately.  The input step is counted
   * as one pass.
   */
-  if (cinfo->progress != NULL && !cinfo->buffered_image &&
+  if (cinfo->progress != NULL && ! cinfo->buffered_image &&
      cinfo->inputctl->has_multiple_scans) {
    int nscans;
    /* Estimate number of scans to set pass_limit. */
@@ -587,7 +597,7 @@ master_selection(j_decompress_ptr cinfo)
      nscans = cinfo->num_components;
    }
    cinfo->progress->pass_counter = 0L;
-    cinfo->progress->pass_limit = (long)cinfo->total_iMCU_rows * nscans;
+    cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows * nscans;
    cinfo->progress->completed_passes = 0;
    cinfo->progress->total_passes = (cinfo->enable_2pass_quant ? 3 : 2);
    /* Count the input pass as done */
@@ -607,9 +617,9 @@ master_selection(j_decompress_ptr cinfo)
 */

 METHODDEF(void)
-prepare_for_output_pass(j_decompress_ptr cinfo)
+prepare_for_output_pass (j_decompress_ptr cinfo)
 {
-  my_master_ptr master = (my_master_ptr)cinfo->master;
+  my_master_ptr master = (my_master_ptr) cinfo->master;

  if (master->pub.is_dummy_pass) {
 #ifdef QUANT_2PASS_SUPPORTED
@@ -635,8 +645,8 @@ prepare_for_output_pass(j_decompress_ptr cinfo)
    }
    (*cinfo->idct->start_pass) (cinfo);
    (*cinfo->coef->start_output_pass) (cinfo);
-    if (!cinfo->raw_data_out) {
-      if (!master->using_merged_upsample)
+    if (! cinfo->raw_data_out) {
+      if (! master->using_merged_upsample)
        (*cinfo->cconvert->start_pass) (cinfo);
      (*cinfo->upsample->start_pass) (cinfo);
      if (cinfo->quantize_colors)
@@ -655,7 +665,7 @@ prepare_for_output_pass(j_decompress_ptr cinfo)
    /* In buffered-image mode, we assume one more output pass if EOI not
     * yet reached, but no more passes if EOI has been reached.
     */
-    if (cinfo->buffered_image && !cinfo->inputctl->eoi_reached) {
+    if (cinfo->buffered_image && ! cinfo->inputctl->eoi_reached) {
      cinfo->progress->total_passes += (cinfo->enable_2pass_quant ? 2 : 1);
    }
  }
@@ -667,9 +677,9 @@ prepare_for_output_pass(j_decompress_ptr cinfo)
 */

 METHODDEF(void)
-finish_output_pass(j_decompress_ptr cinfo)
+finish_output_pass (j_decompress_ptr cinfo)
 {
-  my_master_ptr master = (my_master_ptr)cinfo->master;
+  my_master_ptr master = (my_master_ptr) cinfo->master;

  if (cinfo->quantize_colors)
    (*cinfo->cquantize->finish_pass) (cinfo);
@@ -684,9 +694,9 @@ finish_output_pass(j_decompress_ptr cinfo)
 */

 GLOBAL(void)
-jpeg_new_colormap(j_decompress_ptr cinfo)
+jpeg_new_colormap (j_decompress_ptr cinfo)
 {
-  my_master_ptr master = (my_master_ptr)cinfo->master;
+  my_master_ptr master = (my_master_ptr) cinfo->master;

  /* Prevent application from calling me at wrong times */
  if (cinfo->global_state != DSTATE_BUFIMAGE)
@@ -712,9 +722,9 @@ jpeg_new_colormap(j_decompress_ptr cinfo)
 */

 GLOBAL(void)
-jinit_master_decompress(j_decompress_ptr cinfo)
+jinit_master_decompress (j_decompress_ptr cinfo)
 {
-  my_master_ptr master = (my_master_ptr)cinfo->master;
+  my_master_ptr master = (my_master_ptr) cinfo->master;

  master->pub.prepare_for_output_pass = prepare_for_output_pass;
  master->pub.finish_output_pass = finish_output_pass;
@@ -5,7 +5,7 @@
 * Copyright (C) 1994-1996, Thomas G. Lane.
 * libjpeg-turbo Modifications:
 * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
- * Copyright (C) 2009, 2011, 2014-2015, 2020, D. R. Commander.
+ * Copyright (C) 2009, 2011, 2014-2015, D. R. Commander.
 * Copyright (C) 2013, Linaro Limited.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
@@ -40,16 +40,44 @@
 #define JPEG_INTERNALS
 #include "jinclude.h"
 #include "jpeglib.h"
-#include "jdmerge.h"
 #include "jsimd.h"
 #include "jconfigint.h"

 #ifdef UPSAMPLE_MERGING_SUPPORTED


+/* Private subobject */
+
+typedef struct {
+  struct jpeg_upsampler pub;    /* public fields */
+
+  /* Pointer to routine to do actual upsampling/conversion of one row group */
+  void (*upmethod) (j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                    JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf);
+
+  /* Private state for YCC->RGB conversion */
+  int *Cr_r_tab;                /* => table for Cr to R conversion */
+  int *Cb_b_tab;                /* => table for Cb to B conversion */
+  JLONG *Cr_g_tab;              /* => table for Cr to G conversion */
+  JLONG *Cb_g_tab;              /* => table for Cb to G conversion */
+
+  /* For 2:1 vertical sampling, we produce two output rows at a time.
+   * We need a "spare" row buffer to hold the second output row if the
+   * application provides just a one-row buffer; we also use the spare
+   * to discard the dummy last row if the image height is odd.
+   */
+  JSAMPROW spare_row;
+  boolean spare_full;           /* T if spare buffer is occupied */
+
+  JDIMENSION out_row_width;     /* samples per output row */
+  JDIMENSION rows_to_go;        /* counts rows remaining in image */
+} my_upsampler;
+
+typedef my_upsampler *my_upsample_ptr;
+
 #define SCALEBITS       16      /* speediest right-shift on some machines */
-#define ONE_HALF        ((JLONG)1 << (SCALEBITS - 1))
-#define FIX(x)          ((JLONG)((x) * (1L << SCALEBITS) + 0.5))
+#define ONE_HALF        ((JLONG) 1 << (SCALEBITS-1))
+#define FIX(x)          ((JLONG) ((x) * (1L<<SCALEBITS) + 0.5))


 /* Include inline routines for colorspace extensions */
@@ -60,12 +88,12 @@
 #undef RGB_BLUE
 #undef RGB_PIXELSIZE

-#define RGB_RED  EXT_RGB_RED
-#define RGB_GREEN  EXT_RGB_GREEN
-#define RGB_BLUE  EXT_RGB_BLUE
-#define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
-#define h2v1_merged_upsample_internal  extrgb_h2v1_merged_upsample_internal
-#define h2v2_merged_upsample_internal  extrgb_h2v2_merged_upsample_internal
+#define RGB_RED EXT_RGB_RED
+#define RGB_GREEN EXT_RGB_GREEN
+#define RGB_BLUE EXT_RGB_BLUE
+#define RGB_PIXELSIZE EXT_RGB_PIXELSIZE
+#define h2v1_merged_upsample_internal extrgb_h2v1_merged_upsample_internal
+#define h2v2_merged_upsample_internal extrgb_h2v2_merged_upsample_internal
 #include "jdmrgext.c"
 #undef RGB_RED
 #undef RGB_GREEN
@@ -74,13 +102,13 @@
 #undef h2v1_merged_upsample_internal
 #undef h2v2_merged_upsample_internal

-#define RGB_RED  EXT_RGBX_RED
-#define RGB_GREEN  EXT_RGBX_GREEN
-#define RGB_BLUE  EXT_RGBX_BLUE
-#define RGB_ALPHA  3
-#define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
-#define h2v1_merged_upsample_internal  extrgbx_h2v1_merged_upsample_internal
-#define h2v2_merged_upsample_internal  extrgbx_h2v2_merged_upsample_internal
+#define RGB_RED EXT_RGBX_RED
+#define RGB_GREEN EXT_RGBX_GREEN
+#define RGB_BLUE EXT_RGBX_BLUE
+#define RGB_ALPHA 3
+#define RGB_PIXELSIZE EXT_RGBX_PIXELSIZE
+#define h2v1_merged_upsample_internal extrgbx_h2v1_merged_upsample_internal
+#define h2v2_merged_upsample_internal extrgbx_h2v2_merged_upsample_internal
 #include "jdmrgext.c"
 #undef RGB_RED
 #undef RGB_GREEN
@@ -90,12 +118,12 @@
 #undef h2v1_merged_upsample_internal
 #undef h2v2_merged_upsample_internal

-#define RGB_RED  EXT_BGR_RED
-#define RGB_GREEN  EXT_BGR_GREEN
-#define RGB_BLUE  EXT_BGR_BLUE
-#define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
-#define h2v1_merged_upsample_internal  extbgr_h2v1_merged_upsample_internal
-#define h2v2_merged_upsample_internal  extbgr_h2v2_merged_upsample_internal
+#define RGB_RED EXT_BGR_RED
+#define RGB_GREEN EXT_BGR_GREEN
+#define RGB_BLUE EXT_BGR_BLUE
+#define RGB_PIXELSIZE EXT_BGR_PIXELSIZE
+#define h2v1_merged_upsample_internal extbgr_h2v1_merged_upsample_internal
+#define h2v2_merged_upsample_internal extbgr_h2v2_merged_upsample_internal
 #include "jdmrgext.c"
 #undef RGB_RED
 #undef RGB_GREEN
@@ -104,13 +132,13 @@
 #undef h2v1_merged_upsample_internal
 #undef h2v2_merged_upsample_internal

-#define RGB_RED  EXT_BGRX_RED
-#define RGB_GREEN  EXT_BGRX_GREEN
-#define RGB_BLUE  EXT_BGRX_BLUE
-#define RGB_ALPHA  3
-#define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
-#define h2v1_merged_upsample_internal  extbgrx_h2v1_merged_upsample_internal
-#define h2v2_merged_upsample_internal  extbgrx_h2v2_merged_upsample_internal
+#define RGB_RED EXT_BGRX_RED
+#define RGB_GREEN EXT_BGRX_GREEN
+#define RGB_BLUE EXT_BGRX_BLUE
+#define RGB_ALPHA 3
+#define RGB_PIXELSIZE EXT_BGRX_PIXELSIZE
+#define h2v1_merged_upsample_internal extbgrx_h2v1_merged_upsample_internal
+#define h2v2_merged_upsample_internal extbgrx_h2v2_merged_upsample_internal
 #include "jdmrgext.c"
 #undef RGB_RED
 #undef RGB_GREEN
@@ -120,13 +148,13 @@
 #undef h2v1_merged_upsample_internal
 #undef h2v2_merged_upsample_internal

-#define RGB_RED  EXT_XBGR_RED
-#define RGB_GREEN  EXT_XBGR_GREEN
-#define RGB_BLUE  EXT_XBGR_BLUE
-#define RGB_ALPHA  0
-#define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
-#define h2v1_merged_upsample_internal  extxbgr_h2v1_merged_upsample_internal
-#define h2v2_merged_upsample_internal  extxbgr_h2v2_merged_upsample_internal
+#define RGB_RED EXT_XBGR_RED
+#define RGB_GREEN EXT_XBGR_GREEN
+#define RGB_BLUE EXT_XBGR_BLUE
+#define RGB_ALPHA 0
+#define RGB_PIXELSIZE EXT_XBGR_PIXELSIZE
+#define h2v1_merged_upsample_internal extxbgr_h2v1_merged_upsample_internal
+#define h2v2_merged_upsample_internal extxbgr_h2v2_merged_upsample_internal
 #include "jdmrgext.c"
 #undef RGB_RED
 #undef RGB_GREEN
@@ -136,13 +164,13 @@
 #undef h2v1_merged_upsample_internal
 #undef h2v2_merged_upsample_internal

-#define RGB_RED  EXT_XRGB_RED
-#define RGB_GREEN  EXT_XRGB_GREEN
-#define RGB_BLUE  EXT_XRGB_BLUE
-#define RGB_ALPHA  0
-#define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
-#define h2v1_merged_upsample_internal  extxrgb_h2v1_merged_upsample_internal
-#define h2v2_merged_upsample_internal  extxrgb_h2v2_merged_upsample_internal
+#define RGB_RED EXT_XRGB_RED
+#define RGB_GREEN EXT_XRGB_GREEN
+#define RGB_BLUE EXT_XRGB_BLUE
+#define RGB_ALPHA 0
+#define RGB_PIXELSIZE EXT_XRGB_PIXELSIZE
+#define h2v1_merged_upsample_internal extxrgb_h2v1_merged_upsample_internal
+#define h2v2_merged_upsample_internal extxrgb_h2v2_merged_upsample_internal
 #include "jdmrgext.c"
 #undef RGB_RED
 #undef RGB_GREEN
@@ -159,25 +187,25 @@
 */

 LOCAL(void)
-build_ycc_rgb_table(j_decompress_ptr cinfo)
+build_ycc_rgb_table (j_decompress_ptr cinfo)
 {
-  my_merged_upsample_ptr upsample = (my_merged_upsample_ptr)cinfo->upsample;
+  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
  int i;
  JLONG x;
  SHIFT_TEMPS

  upsample->Cr_r_tab = (int *)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                (MAXJSAMPLE + 1) * sizeof(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));
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+                                (MAXJSAMPLE+1) * sizeof(int));
  upsample->Cr_g_tab = (JLONG *)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                (MAXJSAMPLE + 1) * sizeof(JLONG));
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+                                (MAXJSAMPLE+1) * sizeof(JLONG));
  upsample->Cb_g_tab = (JLONG *)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                (MAXJSAMPLE + 1) * sizeof(JLONG));
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+                                (MAXJSAMPLE+1) * sizeof(JLONG));

  for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
    /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
@@ -189,10 +217,10 @@ build_ycc_rgb_table(j_decompress_ptr cinfo)
    upsample->Cb_b_tab[i] = (int)
                    RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
    /* Cr=>G value is scaled-up -0.71414 * x */
-    upsample->Cr_g_tab[i] = (-FIX(0.71414)) * x;
+    upsample->Cr_g_tab[i] = (- FIX(0.71414)) * x;
    /* Cb=>G value is scaled-up -0.34414 * x */
    /* We also add in ONE_HALF so that need not do it in inner loop */
-    upsample->Cb_g_tab[i] = (-FIX(0.34414)) * x + ONE_HALF;
+    upsample->Cb_g_tab[i] = (- FIX(0.34414)) * x + ONE_HALF;
  }
 }

@@ -202,9 +230,9 @@ build_ycc_rgb_table(j_decompress_ptr cinfo)
 */

 METHODDEF(void)
-start_pass_merged_upsample(j_decompress_ptr cinfo)
+start_pass_merged_upsample (j_decompress_ptr cinfo)
 {
-  my_merged_upsample_ptr upsample = (my_merged_upsample_ptr)cinfo->upsample;
+  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;

  /* Mark the spare buffer empty */
  upsample->spare_full = FALSE;
@@ -220,13 +248,14 @@ start_pass_merged_upsample(j_decompress_ptr cinfo)
 */

 METHODDEF(void)
-merged_2v_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                   JDIMENSION *in_row_group_ctr,
-                   JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf,
-                   JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
+merged_2v_upsample (j_decompress_ptr cinfo,
+                    JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+                    JDIMENSION in_row_groups_avail,
+                    JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+                    JDIMENSION out_rows_avail)
 /* 2:1 vertical sampling case: may need a spare row. */
 {
-  my_merged_upsample_ptr upsample = (my_merged_upsample_ptr)cinfo->upsample;
+  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
  JSAMPROW work_ptrs[2];
  JDIMENSION num_rows;          /* number of rows returned to caller */

@@ -235,8 +264,8 @@ merged_2v_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
    JDIMENSION size = upsample->out_row_width;
    if (cinfo->out_color_space == JCS_RGB565)
      size = cinfo->output_width * 2;
-    jcopy_sample_rows(&upsample->spare_row, 0, output_buf + *out_row_ctr, 0, 1,
-                      size);
+    jcopy_sample_rows(& upsample->spare_row, 0, output_buf + *out_row_ctr, 0,
+                      1, size);
    num_rows = 1;
    upsample->spare_full = FALSE;
  } else {
@@ -265,19 +294,20 @@ merged_2v_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
  *out_row_ctr += num_rows;
  upsample->rows_to_go -= num_rows;
  /* When the buffer is emptied, declare this input row group consumed */
-  if (!upsample->spare_full)
+  if (! upsample->spare_full)
    (*in_row_group_ctr)++;
 }


 METHODDEF(void)
-merged_1v_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                   JDIMENSION *in_row_group_ctr,
-                   JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf,
-                   JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
+merged_1v_upsample (j_decompress_ptr cinfo,
+                    JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+                    JDIMENSION in_row_groups_avail,
+                    JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+                    JDIMENSION out_rows_avail)
 /* 1:1 vertical sampling case: much easier, never need a spare row. */
 {
-  my_merged_upsample_ptr upsample = (my_merged_upsample_ptr)cinfo->upsample;
+  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;

  /* Just do the upsampling. */
  (*upsample->upmethod) (cinfo, input_buf, *in_row_group_ctr,
@@ -303,42 +333,43 @@ merged_1v_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 */

 METHODDEF(void)
-h2v1_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                     JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+h2v1_merged_upsample (j_decompress_ptr cinfo,
+                      JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+                      JSAMPARRAY output_buf)
 {
  switch (cinfo->out_color_space) {
-  case JCS_EXT_RGB:
-    extrgb_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
-                                         output_buf);
-    break;
-  case JCS_EXT_RGBX:
-  case JCS_EXT_RGBA:
-    extrgbx_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
-                                          output_buf);
-    break;
-  case JCS_EXT_BGR:
-    extbgr_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
-                                         output_buf);
-    break;
-  case JCS_EXT_BGRX:
-  case JCS_EXT_BGRA:
-    extbgrx_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
-                                          output_buf);
-    break;
-  case JCS_EXT_XBGR:
-  case JCS_EXT_ABGR:
-    extxbgr_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
-                                          output_buf);
-    break;
-  case JCS_EXT_XRGB:
-  case JCS_EXT_ARGB:
-    extxrgb_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
-                                          output_buf);
-    break;
-  default:
-    h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
-                                  output_buf);
-    break;
+    case JCS_EXT_RGB:
+      extrgb_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                           output_buf);
+      break;
+    case JCS_EXT_RGBX:
+    case JCS_EXT_RGBA:
+      extrgbx_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                            output_buf);
+      break;
+    case JCS_EXT_BGR:
+      extbgr_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                           output_buf);
+      break;
+    case JCS_EXT_BGRX:
+    case JCS_EXT_BGRA:
+      extbgrx_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                            output_buf);
+      break;
+    case JCS_EXT_XBGR:
+    case JCS_EXT_ABGR:
+      extxbgr_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                            output_buf);
+      break;
+    case JCS_EXT_XRGB:
+    case JCS_EXT_ARGB:
+      extxrgb_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                            output_buf);
+      break;
+    default:
+      h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                    output_buf);
+      break;
  }
 }

@@ -348,42 +379,43 @@ h2v1_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 */

 METHODDEF(void)
-h2v2_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                     JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+h2v2_merged_upsample (j_decompress_ptr cinfo,
+                      JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+                      JSAMPARRAY output_buf)
 {
  switch (cinfo->out_color_space) {
-  case JCS_EXT_RGB:
-    extrgb_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
-                                         output_buf);
-    break;
-  case JCS_EXT_RGBX:
-  case JCS_EXT_RGBA:
-    extrgbx_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
-                                          output_buf);
-    break;
-  case JCS_EXT_BGR:
-    extbgr_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
-                                         output_buf);
-    break;
-  case JCS_EXT_BGRX:
-  case JCS_EXT_BGRA:
-    extbgrx_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
-                                          output_buf);
-    break;
-  case JCS_EXT_XBGR:
-  case JCS_EXT_ABGR:
-    extxbgr_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
-                                          output_buf);
-    break;
-  case JCS_EXT_XRGB:
-  case JCS_EXT_ARGB:
-    extxrgb_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
-                                          output_buf);
-    break;
-  default:
-    h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
-                                  output_buf);
-    break;
+    case JCS_EXT_RGB:
+      extrgb_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                           output_buf);
+      break;
+    case JCS_EXT_RGBX:
+    case JCS_EXT_RGBA:
+      extrgbx_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                            output_buf);
+      break;
+    case JCS_EXT_BGR:
+      extbgr_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                           output_buf);
+      break;
+    case JCS_EXT_BGRX:
+    case JCS_EXT_BGRA:
+      extbgrx_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                            output_buf);
+      break;
+    case JCS_EXT_XBGR:
+    case JCS_EXT_ABGR:
+      extxbgr_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                            output_buf);
+      break;
+    case JCS_EXT_XRGB:
+    case JCS_EXT_ARGB:
+      extxrgb_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                            output_buf);
+      break;
+    default:
+      h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                    output_buf);
+      break;
  }
 }

@@ -392,21 +424,24 @@ h2v2_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 * RGB565 conversion
 */

-#define PACK_SHORT_565_LE(r, g, b) \
-  ((((r) << 8) & 0xF800) | (((g) << 3) & 0x7E0) | ((b) >> 3))
-#define PACK_SHORT_565_BE(r, g, b) \
-  (((r) & 0xF8) | ((g) >> 5) | (((g) << 11) & 0xE000) | (((b) << 5) & 0x1F00))
+#define PACK_SHORT_565_LE(r, g, b)   ((((r) << 8) & 0xF800) |  \
+                                      (((g) << 3) & 0x7E0) | ((b) >> 3))
+#define PACK_SHORT_565_BE(r, g, b)   (((r) & 0xF8) | ((g) >> 5) |  \
+                                      (((g) << 11) & 0xE000) |  \
+                                      (((b) << 5) & 0x1F00))

-#define PACK_TWO_PIXELS_LE(l, r)    ((r << 16) | l)
-#define PACK_TWO_PIXELS_BE(l, r)    ((l << 16) | r)
+#define PACK_TWO_PIXELS_LE(l, r)     ((r << 16) | l)
+#define PACK_TWO_PIXELS_BE(l, r)     ((l << 16) | r)

-#define WRITE_TWO_PIXELS_LE(addr, pixels) { \
-  ((INT16 *)(addr))[0] = (INT16)(pixels); \
-  ((INT16 *)(addr))[1] = (INT16)((pixels) >> 16); \
+#define PACK_NEED_ALIGNMENT(ptr)  (((size_t)(ptr)) & 3)
+
+#define WRITE_TWO_PIXELS_LE(addr, pixels) {  \
+  ((INT16*)(addr))[0] = (INT16)(pixels);  \
+  ((INT16*)(addr))[1] = (INT16)((pixels) >> 16);  \
 }
-#define WRITE_TWO_PIXELS_BE(addr, pixels) { \
-  ((INT16 *)(addr))[1] = (INT16)(pixels); \
-  ((INT16 *)(addr))[0] = (INT16)((pixels) >> 16); \
+#define WRITE_TWO_PIXELS_BE(addr, pixels) {  \
+  ((INT16*)(addr))[1] = (INT16)(pixels);  \
+  ((INT16*)(addr))[0] = (INT16)((pixels) >> 16);  \
 }

 #define DITHER_565_R(r, dither)  ((r) + ((dither) & 0xFF))
@@ -417,7 +452,7 @@ h2v2_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 /* Declarations for ordered dithering
 *
 * We use a 4x4 ordered dither array packed into 32 bits.  This array is
- * sufficient for dithering RGB888 to RGB565.
+ * sufficent for dithering RGB888 to RGB565.
 */

 #define DITHER_MASK       0x3
@@ -432,13 +467,13 @@ static const JLONG dither_matrix[4] = {

 /* Include inline routines for RGB565 conversion */

-#define PACK_SHORT_565  PACK_SHORT_565_LE
-#define PACK_TWO_PIXELS  PACK_TWO_PIXELS_LE
-#define WRITE_TWO_PIXELS  WRITE_TWO_PIXELS_LE
-#define h2v1_merged_upsample_565_internal  h2v1_merged_upsample_565_le
-#define h2v1_merged_upsample_565D_internal  h2v1_merged_upsample_565D_le
-#define h2v2_merged_upsample_565_internal  h2v2_merged_upsample_565_le
-#define h2v2_merged_upsample_565D_internal  h2v2_merged_upsample_565D_le
+#define PACK_SHORT_565 PACK_SHORT_565_LE
+#define PACK_TWO_PIXELS PACK_TWO_PIXELS_LE
+#define WRITE_TWO_PIXELS WRITE_TWO_PIXELS_LE
+#define h2v1_merged_upsample_565_internal h2v1_merged_upsample_565_le
+#define h2v1_merged_upsample_565D_internal h2v1_merged_upsample_565D_le
+#define h2v2_merged_upsample_565_internal h2v2_merged_upsample_565_le
+#define h2v2_merged_upsample_565D_internal h2v2_merged_upsample_565D_le
 #include "jdmrg565.c"
 #undef PACK_SHORT_565
 #undef PACK_TWO_PIXELS
@@ -448,13 +483,13 @@ static const JLONG dither_matrix[4] = {
 #undef h2v2_merged_upsample_565_internal
 #undef h2v2_merged_upsample_565D_internal

-#define PACK_SHORT_565  PACK_SHORT_565_BE
-#define PACK_TWO_PIXELS  PACK_TWO_PIXELS_BE
-#define WRITE_TWO_PIXELS  WRITE_TWO_PIXELS_BE
-#define h2v1_merged_upsample_565_internal  h2v1_merged_upsample_565_be
-#define h2v1_merged_upsample_565D_internal  h2v1_merged_upsample_565D_be
-#define h2v2_merged_upsample_565_internal  h2v2_merged_upsample_565_be
-#define h2v2_merged_upsample_565D_internal  h2v2_merged_upsample_565D_be
+#define PACK_SHORT_565 PACK_SHORT_565_BE
+#define PACK_TWO_PIXELS PACK_TWO_PIXELS_BE
+#define WRITE_TWO_PIXELS WRITE_TWO_PIXELS_BE
+#define h2v1_merged_upsample_565_internal h2v1_merged_upsample_565_be
+#define h2v1_merged_upsample_565D_internal h2v1_merged_upsample_565D_be
+#define h2v2_merged_upsample_565_internal h2v2_merged_upsample_565_be
+#define h2v2_merged_upsample_565D_internal h2v2_merged_upsample_565D_be
 #include "jdmrg565.c"
 #undef PACK_SHORT_565
 #undef PACK_TWO_PIXELS
@@ -475,8 +510,9 @@ static INLINE boolean is_big_endian(void)


 METHODDEF(void)
-h2v1_merged_upsample_565(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                         JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+h2v1_merged_upsample_565 (j_decompress_ptr cinfo,
+                          JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+                          JSAMPARRAY output_buf)
 {
  if (is_big_endian())
    h2v1_merged_upsample_565_be(cinfo, input_buf, in_row_group_ctr,
@@ -484,12 +520,13 @@ h2v1_merged_upsample_565(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
  else
    h2v1_merged_upsample_565_le(cinfo, input_buf, in_row_group_ctr,
                                output_buf);
-}
+ }


 METHODDEF(void)
-h2v1_merged_upsample_565D(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                          JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+h2v1_merged_upsample_565D (j_decompress_ptr cinfo,
+                           JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+                           JSAMPARRAY output_buf)
 {
  if (is_big_endian())
    h2v1_merged_upsample_565D_be(cinfo, input_buf, in_row_group_ctr,
@@ -501,8 +538,9 @@ h2v1_merged_upsample_565D(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,


 METHODDEF(void)
-h2v2_merged_upsample_565(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                         JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+h2v2_merged_upsample_565 (j_decompress_ptr cinfo,
+                          JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+                          JSAMPARRAY output_buf)
 {
  if (is_big_endian())
    h2v2_merged_upsample_565_be(cinfo, input_buf, in_row_group_ctr,
@@ -514,8 +552,9 @@ h2v2_merged_upsample_565(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,


 METHODDEF(void)
-h2v2_merged_upsample_565D(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                          JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+h2v2_merged_upsample_565D (j_decompress_ptr cinfo,
+                           JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+                           JSAMPARRAY output_buf)
 {
  if (is_big_endian())
    h2v2_merged_upsample_565D_be(cinfo, input_buf, in_row_group_ctr,
@@ -535,14 +574,14 @@ h2v2_merged_upsample_565D(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 */

 GLOBAL(void)
-jinit_merged_upsampler(j_decompress_ptr cinfo)
+jinit_merged_upsampler (j_decompress_ptr cinfo)
 {
-  my_merged_upsample_ptr upsample;
+  my_upsample_ptr upsample;

-  upsample = (my_merged_upsample_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                sizeof(my_merged_upsampler));
-  cinfo->upsample = (struct jpeg_upsampler *)upsample;
+  upsample = (my_upsample_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+                                sizeof(my_upsampler));
+  cinfo->upsample = (struct jpeg_upsampler *) upsample;
  upsample->pub.start_pass = start_pass_merged_upsample;
  upsample->pub.need_context_rows = FALSE;

@@ -563,8 +602,8 @@ jinit_merged_upsampler(j_decompress_ptr cinfo)
    }
    /* 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)));
+      (*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;
    if (jsimd_can_h2v1_merged_upsample())
@@ -1,47 +0,0 @@
-/*
- * jdmerge.h
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1994-1996, Thomas G. Lane.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2020, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- */
-
-#define JPEG_INTERNALS
-#include "jpeglib.h"
-
-#ifdef UPSAMPLE_MERGING_SUPPORTED
-
-
-/* Private subobject */
-
-typedef struct {
-  struct jpeg_upsampler pub;    /* public fields */
-
-  /* Pointer to routine to do actual upsampling/conversion of one row group */
-  void (*upmethod) (j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                    JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf);
-
-  /* Private state for YCC->RGB conversion */
-  int *Cr_r_tab;                /* => table for Cr to R conversion */
-  int *Cb_b_tab;                /* => table for Cb to B conversion */
-  JLONG *Cr_g_tab;              /* => table for Cr to G conversion */
-  JLONG *Cb_g_tab;              /* => table for Cb to G conversion */
-
-  /* For 2:1 vertical sampling, we produce two output rows at a time.
-   * We need a "spare" row buffer to hold the second output row if the
-   * application provides just a one-row buffer; we also use the spare
-   * to discard the dummy last row if the image height is odd.
-   */
-  JSAMPROW spare_row;
-  boolean spare_full;           /* T if spare buffer is occupied */
-
-  JDIMENSION out_row_width;     /* samples per output row */
-  JDIMENSION rows_to_go;        /* counts rows remaining in image */
-} my_merged_upsampler;
-
-typedef my_merged_upsampler *my_merged_upsample_ptr;
-
-#endif /* UPSAMPLE_MERGING_SUPPORTED */
@@ -5,7 +5,7 @@
 * Copyright (C) 1994-1996, Thomas G. Lane.
 * libjpeg-turbo Modifications:
 * Copyright (C) 2013, Linaro Limited.
- * Copyright (C) 2014-2015, 2018, 2020, D. R. Commander.
+ * Copyright (C) 2014-2015, D. R. Commander.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
 *
@@ -15,22 +15,23 @@

 INLINE
 LOCAL(void)
-h2v1_merged_upsample_565_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                                  JDIMENSION in_row_group_ctr,
-                                  JSAMPARRAY output_buf)
+h2v1_merged_upsample_565_internal (j_decompress_ptr cinfo,
+                                   JSAMPIMAGE input_buf,
+                                   JDIMENSION in_row_group_ctr,
+                                   JSAMPARRAY output_buf)
 {
-  my_merged_upsample_ptr upsample = (my_merged_upsample_ptr)cinfo->upsample;
+  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
  register int y, cred, cgreen, cblue;
  int cb, cr;
  register JSAMPROW outptr;
  JSAMPROW inptr0, inptr1, inptr2;
  JDIMENSION col;
  /* copy these pointers into registers if possible */
-  register JSAMPLE *range_limit = cinfo->sample_range_limit;
-  int *Crrtab = upsample->Cr_r_tab;
-  int *Cbbtab = upsample->Cb_b_tab;
-  JLONG *Crgtab = upsample->Cr_g_tab;
-  JLONG *Cbgtab = upsample->Cb_g_tab;
+  register JSAMPLE * range_limit = cinfo->sample_range_limit;
+  int * Crrtab = upsample->Cr_r_tab;
+  int * Cbbtab = upsample->Cb_b_tab;
+  JLONG * Crgtab = upsample->Cr_g_tab;
+  JLONG * Cbgtab = upsample->Cb_g_tab;
  unsigned int r, g, b;
  JLONG rgb;
  SHIFT_TEMPS
@@ -43,20 +44,20 @@ h2v1_merged_upsample_565_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
  /* Loop for each pair of output pixels */
  for (col = cinfo->output_width >> 1; col > 0; col--) {
    /* Do the chroma part of the calculation */
-    cb = *inptr1++;
-    cr = *inptr2++;
+    cb = GETJSAMPLE(*inptr1++);
+    cr = GETJSAMPLE(*inptr2++);
    cred = Crrtab[cr];
-    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+    cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
    cblue = Cbbtab[cb];

    /* Fetch 2 Y values and emit 2 pixels */
-    y  = *inptr0++;
+    y  = GETJSAMPLE(*inptr0++);
    r = range_limit[y + cred];
    g = range_limit[y + cgreen];
    b = range_limit[y + cblue];
    rgb = PACK_SHORT_565(r, g, b);

-    y  = *inptr0++;
+    y  = GETJSAMPLE(*inptr0++);
    r = range_limit[y + cred];
    g = range_limit[y + cgreen];
    b = range_limit[y + cblue];
@@ -68,40 +69,40 @@ h2v1_merged_upsample_565_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,

  /* If image width is odd, do the last output column separately */
  if (cinfo->output_width & 1) {
-    cb = *inptr1;
-    cr = *inptr2;
+    cb = GETJSAMPLE(*inptr1);
+    cr = GETJSAMPLE(*inptr2);
    cred = Crrtab[cr];
-    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+    cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
    cblue = Cbbtab[cb];
-    y  = *inptr0;
+    y  = GETJSAMPLE(*inptr0);
    r = range_limit[y + cred];
    g = range_limit[y + cgreen];
    b = range_limit[y + cblue];
    rgb = PACK_SHORT_565(r, g, b);
-    *(INT16 *)outptr = (INT16)rgb;
-  }
-}
+    *(INT16*)outptr = (INT16)rgb;
+   }
+ }


 INLINE
 LOCAL(void)
-h2v1_merged_upsample_565D_internal(j_decompress_ptr cinfo,
-                                   JSAMPIMAGE input_buf,
-                                   JDIMENSION in_row_group_ctr,
-                                   JSAMPARRAY output_buf)
+h2v1_merged_upsample_565D_internal (j_decompress_ptr cinfo,
+                                    JSAMPIMAGE input_buf,
+                                    JDIMENSION in_row_group_ctr,
+                                    JSAMPARRAY output_buf)
 {
-  my_merged_upsample_ptr upsample = (my_merged_upsample_ptr)cinfo->upsample;
+  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
  register int y, cred, cgreen, cblue;
  int cb, cr;
  register JSAMPROW outptr;
  JSAMPROW inptr0, inptr1, inptr2;
  JDIMENSION col;
  /* copy these pointers into registers if possible */
-  register JSAMPLE *range_limit = cinfo->sample_range_limit;
-  int *Crrtab = upsample->Cr_r_tab;
-  int *Cbbtab = upsample->Cb_b_tab;
-  JLONG *Crgtab = upsample->Cr_g_tab;
-  JLONG *Cbgtab = upsample->Cb_g_tab;
+  register JSAMPLE * range_limit = cinfo->sample_range_limit;
+  int * Crrtab = upsample->Cr_r_tab;
+  int * Cbbtab = upsample->Cb_b_tab;
+  JLONG * Crgtab = upsample->Cr_g_tab;
+  JLONG * Cbgtab = upsample->Cb_g_tab;
  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];
  unsigned int r, g, b;
  JLONG rgb;
@@ -115,21 +116,21 @@ h2v1_merged_upsample_565D_internal(j_decompress_ptr cinfo,
  /* Loop for each pair of output pixels */
  for (col = cinfo->output_width >> 1; col > 0; col--) {
    /* Do the chroma part of the calculation */
-    cb = *inptr1++;
-    cr = *inptr2++;
+    cb = GETJSAMPLE(*inptr1++);
+    cr = GETJSAMPLE(*inptr2++);
    cred = Crrtab[cr];
-    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+    cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
    cblue = Cbbtab[cb];

    /* Fetch 2 Y values and emit 2 pixels */
-    y  = *inptr0++;
+    y  = GETJSAMPLE(*inptr0++);
    r = range_limit[DITHER_565_R(y + cred, d0)];
    g = range_limit[DITHER_565_G(y + cgreen, d0)];
    b = range_limit[DITHER_565_B(y + cblue, d0)];
    d0 = DITHER_ROTATE(d0);
    rgb = PACK_SHORT_565(r, g, b);

-    y  = *inptr0++;
+    y  = GETJSAMPLE(*inptr0++);
    r = range_limit[DITHER_565_R(y + cred, d0)];
    g = range_limit[DITHER_565_G(y + cgreen, d0)];
    b = range_limit[DITHER_565_B(y + cblue, d0)];
@@ -142,39 +143,40 @@ h2v1_merged_upsample_565D_internal(j_decompress_ptr cinfo,

  /* If image width is odd, do the last output column separately */
  if (cinfo->output_width & 1) {
-    cb = *inptr1;
-    cr = *inptr2;
+    cb = GETJSAMPLE(*inptr1);
+    cr = GETJSAMPLE(*inptr2);
    cred = Crrtab[cr];
-    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+    cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
    cblue = Cbbtab[cb];
-    y  = *inptr0;
+    y  = GETJSAMPLE(*inptr0);
    r = range_limit[DITHER_565_R(y + cred, d0)];
    g = range_limit[DITHER_565_G(y + cgreen, d0)];
    b = range_limit[DITHER_565_B(y + cblue, d0)];
    rgb = PACK_SHORT_565(r, g, b);
-    *(INT16 *)outptr = (INT16)rgb;
+    *(INT16*)outptr = (INT16)rgb;
  }
 }


 INLINE
 LOCAL(void)
-h2v2_merged_upsample_565_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                                  JDIMENSION in_row_group_ctr,
-                                  JSAMPARRAY output_buf)
+h2v2_merged_upsample_565_internal (j_decompress_ptr cinfo,
+                                   JSAMPIMAGE input_buf,
+                                   JDIMENSION in_row_group_ctr,
+                                   JSAMPARRAY output_buf)
 {
-  my_merged_upsample_ptr upsample = (my_merged_upsample_ptr)cinfo->upsample;
+  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
  register int y, cred, cgreen, cblue;
  int cb, cr;
  register JSAMPROW outptr0, outptr1;
  JSAMPROW inptr00, inptr01, inptr1, inptr2;
  JDIMENSION col;
  /* copy these pointers into registers if possible */
-  register JSAMPLE *range_limit = cinfo->sample_range_limit;
-  int *Crrtab = upsample->Cr_r_tab;
-  int *Cbbtab = upsample->Cb_b_tab;
-  JLONG *Crgtab = upsample->Cr_g_tab;
-  JLONG *Cbgtab = upsample->Cb_g_tab;
+  register JSAMPLE * range_limit = cinfo->sample_range_limit;
+  int * Crrtab = upsample->Cr_r_tab;
+  int * Cbbtab = upsample->Cb_b_tab;
+  JLONG * Crgtab = upsample->Cr_g_tab;
+  JLONG * Cbgtab = upsample->Cb_g_tab;
  unsigned int r, g, b;
  JLONG rgb;
  SHIFT_TEMPS
@@ -189,20 +191,20 @@ h2v2_merged_upsample_565_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
  /* Loop for each group of output pixels */
  for (col = cinfo->output_width >> 1; col > 0; col--) {
    /* Do the chroma part of the calculation */
-    cb = *inptr1++;
-    cr = *inptr2++;
+    cb = GETJSAMPLE(*inptr1++);
+    cr = GETJSAMPLE(*inptr2++);
    cred = Crrtab[cr];
-    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+    cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
    cblue = Cbbtab[cb];

    /* Fetch 4 Y values and emit 4 pixels */
-    y  = *inptr00++;
+    y  = GETJSAMPLE(*inptr00++);
    r = range_limit[y + cred];
    g = range_limit[y + cgreen];
    b = range_limit[y + cblue];
    rgb = PACK_SHORT_565(r, g, b);

-    y  = *inptr00++;
+    y  = GETJSAMPLE(*inptr00++);
    r = range_limit[y + cred];
    g = range_limit[y + cgreen];
    b = range_limit[y + cblue];
@@ -211,13 +213,13 @@ h2v2_merged_upsample_565_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
    WRITE_TWO_PIXELS(outptr0, rgb);
    outptr0 += 4;

-    y  = *inptr01++;
+    y  = GETJSAMPLE(*inptr01++);
    r = range_limit[y + cred];
    g = range_limit[y + cgreen];
    b = range_limit[y + cblue];
    rgb = PACK_SHORT_565(r, g, b);

-    y  = *inptr01++;
+    y  = GETJSAMPLE(*inptr01++);
    r = range_limit[y + cred];
    g = range_limit[y + cgreen];
    b = range_limit[y + cblue];
@@ -229,56 +231,56 @@ h2v2_merged_upsample_565_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,

  /* If image width is odd, do the last output column separately */
  if (cinfo->output_width & 1) {
-    cb = *inptr1;
-    cr = *inptr2;
+    cb = GETJSAMPLE(*inptr1);
+    cr = GETJSAMPLE(*inptr2);
    cred = Crrtab[cr];
-    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+    cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
    cblue = Cbbtab[cb];

-    y  = *inptr00;
+    y  = GETJSAMPLE(*inptr00);
    r = range_limit[y + cred];
    g = range_limit[y + cgreen];
    b = range_limit[y + cblue];
    rgb = PACK_SHORT_565(r, g, b);
-    *(INT16 *)outptr0 = (INT16)rgb;
+    *(INT16*)outptr0 = (INT16)rgb;

-    y  = *inptr01;
+    y  = GETJSAMPLE(*inptr01);
    r = range_limit[y + cred];
    g = range_limit[y + cgreen];
    b = range_limit[y + cblue];
    rgb = PACK_SHORT_565(r, g, b);
-    *(INT16 *)outptr1 = (INT16)rgb;
+    *(INT16*)outptr1 = (INT16)rgb;
  }
 }


 INLINE
 LOCAL(void)
-h2v2_merged_upsample_565D_internal(j_decompress_ptr cinfo,
-                                   JSAMPIMAGE input_buf,
-                                   JDIMENSION in_row_group_ctr,
-                                   JSAMPARRAY output_buf)
+h2v2_merged_upsample_565D_internal (j_decompress_ptr cinfo,
+                                    JSAMPIMAGE input_buf,
+                                    JDIMENSION in_row_group_ctr,
+                                    JSAMPARRAY output_buf)
 {
-  my_merged_upsample_ptr upsample = (my_merged_upsample_ptr)cinfo->upsample;
+  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
  register int y, cred, cgreen, cblue;
  int cb, cr;
  register JSAMPROW outptr0, outptr1;
  JSAMPROW inptr00, inptr01, inptr1, inptr2;
  JDIMENSION col;
  /* copy these pointers into registers if possible */
-  register JSAMPLE *range_limit = cinfo->sample_range_limit;
-  int *Crrtab = upsample->Cr_r_tab;
-  int *Cbbtab = upsample->Cb_b_tab;
-  JLONG *Crgtab = upsample->Cr_g_tab;
-  JLONG *Cbgtab = upsample->Cb_g_tab;
+  register JSAMPLE * range_limit = cinfo->sample_range_limit;
+  int * Crrtab = upsample->Cr_r_tab;
+  int * Cbbtab = upsample->Cb_b_tab;
+  JLONG * Crgtab = upsample->Cr_g_tab;
+  JLONG * Cbgtab = upsample->Cb_g_tab;
  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];
-  JLONG d1 = dither_matrix[(cinfo->output_scanline + 1) & DITHER_MASK];
+  JLONG d1 = dither_matrix[(cinfo->output_scanline+1) & DITHER_MASK];
  unsigned int r, g, b;
  JLONG rgb;
  SHIFT_TEMPS

-  inptr00 = input_buf[0][in_row_group_ctr * 2];
-  inptr01 = input_buf[0][in_row_group_ctr * 2 + 1];
+  inptr00 = input_buf[0][in_row_group_ctr*2];
+  inptr01 = input_buf[0][in_row_group_ctr*2 + 1];
  inptr1 = input_buf[1][in_row_group_ctr];
  inptr2 = input_buf[2][in_row_group_ctr];
  outptr0 = output_buf[0];
@@ -287,38 +289,38 @@ h2v2_merged_upsample_565D_internal(j_decompress_ptr cinfo,
  /* Loop for each group of output pixels */
  for (col = cinfo->output_width >> 1; col > 0; col--) {
    /* Do the chroma part of the calculation */
-    cb = *inptr1++;
-    cr = *inptr2++;
+    cb = GETJSAMPLE(*inptr1++);
+    cr = GETJSAMPLE(*inptr2++);
    cred = Crrtab[cr];
-    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+    cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
    cblue = Cbbtab[cb];

    /* Fetch 4 Y values and emit 4 pixels */
-    y  = *inptr00++;
+    y  = GETJSAMPLE(*inptr00++);
    r = range_limit[DITHER_565_R(y + cred, d0)];
    g = range_limit[DITHER_565_G(y + cgreen, d0)];
    b = range_limit[DITHER_565_B(y + cblue, d0)];
    d0 = DITHER_ROTATE(d0);
    rgb = PACK_SHORT_565(r, g, b);

-    y  = *inptr00++;
-    r = range_limit[DITHER_565_R(y + cred, d0)];
-    g = range_limit[DITHER_565_G(y + cgreen, d0)];
-    b = range_limit[DITHER_565_B(y + cblue, d0)];
-    d0 = DITHER_ROTATE(d0);
+    y  = GETJSAMPLE(*inptr00++);
+    r = range_limit[DITHER_565_R(y + cred, d1)];
+    g = range_limit[DITHER_565_G(y + cgreen, d1)];
+    b = range_limit[DITHER_565_B(y + cblue, d1)];
+    d1 = DITHER_ROTATE(d1);
    rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));

    WRITE_TWO_PIXELS(outptr0, rgb);
    outptr0 += 4;

-    y  = *inptr01++;
-    r = range_limit[DITHER_565_R(y + cred, d1)];
-    g = range_limit[DITHER_565_G(y + cgreen, d1)];
-    b = range_limit[DITHER_565_B(y + cblue, d1)];
-    d1 = DITHER_ROTATE(d1);
+    y  = GETJSAMPLE(*inptr01++);
+    r = range_limit[DITHER_565_R(y + cred, d0)];
+    g = range_limit[DITHER_565_G(y + cgreen, d0)];
+    b = range_limit[DITHER_565_B(y + cblue, d0)];
+    d0 = DITHER_ROTATE(d0);
    rgb = PACK_SHORT_565(r, g, b);

-    y  = *inptr01++;
+    y  = GETJSAMPLE(*inptr01++);
    r = range_limit[DITHER_565_R(y + cred, d1)];
    g = range_limit[DITHER_565_G(y + cgreen, d1)];
    b = range_limit[DITHER_565_B(y + cblue, d1)];
@@ -331,24 +333,24 @@ h2v2_merged_upsample_565D_internal(j_decompress_ptr cinfo,

  /* If image width is odd, do the last output column separately */
  if (cinfo->output_width & 1) {
-    cb = *inptr1;
-    cr = *inptr2;
+    cb = GETJSAMPLE(*inptr1);
+    cr = GETJSAMPLE(*inptr2);
    cred = Crrtab[cr];
-    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+    cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
    cblue = Cbbtab[cb];

-    y  = *inptr00;
+    y  = GETJSAMPLE(*inptr00);
    r = range_limit[DITHER_565_R(y + cred, d0)];
    g = range_limit[DITHER_565_G(y + cgreen, d0)];
    b = range_limit[DITHER_565_B(y + cblue, d0)];
    rgb = PACK_SHORT_565(r, g, b);
-    *(INT16 *)outptr0 = (INT16)rgb;
+    *(INT16*)outptr0 = (INT16)rgb;

-    y  = *inptr01;
+    y  = GETJSAMPLE(*inptr01);
    r = range_limit[DITHER_565_R(y + cred, d1)];
    g = range_limit[DITHER_565_G(y + cgreen, d1)];
    b = range_limit[DITHER_565_B(y + cblue, d1)];
    rgb = PACK_SHORT_565(r, g, b);
-    *(INT16 *)outptr1 = (INT16)rgb;
+    *(INT16*)outptr1 = (INT16)rgb;
  }
 }
@@ -4,7 +4,7 @@
 * This file was part of the Independent JPEG Group's software:
 * Copyright (C) 1994-1996, Thomas G. Lane.
 * libjpeg-turbo Modifications:
- * Copyright (C) 2011, 2015, 2020, D. R. Commander.
+ * Copyright (C) 2011, 2015, D. R. Commander.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
 *
@@ -21,22 +21,23 @@

 INLINE
 LOCAL(void)
-h2v1_merged_upsample_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                              JDIMENSION in_row_group_ctr,
-                              JSAMPARRAY output_buf)
+h2v1_merged_upsample_internal (j_decompress_ptr cinfo,
+                               JSAMPIMAGE input_buf,
+                               JDIMENSION in_row_group_ctr,
+                               JSAMPARRAY output_buf)
 {
-  my_merged_upsample_ptr upsample = (my_merged_upsample_ptr)cinfo->upsample;
+  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
  register int y, cred, cgreen, cblue;
  int cb, cr;
  register JSAMPROW outptr;
  JSAMPROW inptr0, inptr1, inptr2;
  JDIMENSION col;
  /* copy these pointers into registers if possible */
-  register JSAMPLE *range_limit = cinfo->sample_range_limit;
-  int *Crrtab = upsample->Cr_r_tab;
-  int *Cbbtab = upsample->Cb_b_tab;
-  JLONG *Crgtab = upsample->Cr_g_tab;
-  JLONG *Cbgtab = upsample->Cb_g_tab;
+  register JSAMPLE * range_limit = cinfo->sample_range_limit;
+  int * Crrtab = upsample->Cr_r_tab;
+  int * Cbbtab = upsample->Cb_b_tab;
+  JLONG * Crgtab = upsample->Cr_g_tab;
+  JLONG * Cbgtab = upsample->Cb_g_tab;
  SHIFT_TEMPS

  inptr0 = input_buf[0][in_row_group_ctr];
@@ -46,13 +47,13 @@ h2v1_merged_upsample_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
  /* Loop for each pair of output pixels */
  for (col = cinfo->output_width >> 1; col > 0; col--) {
    /* Do the chroma part of the calculation */
-    cb = *inptr1++;
-    cr = *inptr2++;
+    cb = GETJSAMPLE(*inptr1++);
+    cr = GETJSAMPLE(*inptr2++);
    cred = Crrtab[cr];
-    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+    cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
    cblue = Cbbtab[cb];
    /* Fetch 2 Y values and emit 2 pixels */
-    y  = *inptr0++;
+    y  = GETJSAMPLE(*inptr0++);
    outptr[RGB_RED] =   range_limit[y + cred];
    outptr[RGB_GREEN] = range_limit[y + cgreen];
    outptr[RGB_BLUE] =  range_limit[y + cblue];
@@ -60,7 +61,7 @@ h2v1_merged_upsample_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
    outptr[RGB_ALPHA] = 0xFF;
 #endif
    outptr += RGB_PIXELSIZE;
-    y  = *inptr0++;
+    y  = GETJSAMPLE(*inptr0++);
    outptr[RGB_RED] =   range_limit[y + cred];
    outptr[RGB_GREEN] = range_limit[y + cgreen];
    outptr[RGB_BLUE] =  range_limit[y + cblue];
@@ -71,12 +72,12 @@ h2v1_merged_upsample_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
  }
  /* If image width is odd, do the last output column separately */
  if (cinfo->output_width & 1) {
-    cb = *inptr1;
-    cr = *inptr2;
+    cb = GETJSAMPLE(*inptr1);
+    cr = GETJSAMPLE(*inptr2);
    cred = Crrtab[cr];
-    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+    cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
    cblue = Cbbtab[cb];
-    y  = *inptr0;
+    y  = GETJSAMPLE(*inptr0);
    outptr[RGB_RED] =   range_limit[y + cred];
    outptr[RGB_GREEN] = range_limit[y + cgreen];
    outptr[RGB_BLUE] =  range_limit[y + cblue];
@@ -93,26 +94,27 @@ h2v1_merged_upsample_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,

 INLINE
 LOCAL(void)
-h2v2_merged_upsample_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                              JDIMENSION in_row_group_ctr,
-                              JSAMPARRAY output_buf)
+h2v2_merged_upsample_internal (j_decompress_ptr cinfo,
+                               JSAMPIMAGE input_buf,
+                               JDIMENSION in_row_group_ctr,
+                               JSAMPARRAY output_buf)
 {
-  my_merged_upsample_ptr upsample = (my_merged_upsample_ptr)cinfo->upsample;
+  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
  register int y, cred, cgreen, cblue;
  int cb, cr;
  register JSAMPROW outptr0, outptr1;
  JSAMPROW inptr00, inptr01, inptr1, inptr2;
  JDIMENSION col;
  /* copy these pointers into registers if possible */
-  register JSAMPLE *range_limit = cinfo->sample_range_limit;
-  int *Crrtab = upsample->Cr_r_tab;
-  int *Cbbtab = upsample->Cb_b_tab;
-  JLONG *Crgtab = upsample->Cr_g_tab;
-  JLONG *Cbgtab = upsample->Cb_g_tab;
+  register JSAMPLE * range_limit = cinfo->sample_range_limit;
+  int * Crrtab = upsample->Cr_r_tab;
+  int * Cbbtab = upsample->Cb_b_tab;
+  JLONG * Crgtab = upsample->Cr_g_tab;
+  JLONG * Cbgtab = upsample->Cb_g_tab;
  SHIFT_TEMPS

-  inptr00 = input_buf[0][in_row_group_ctr * 2];
-  inptr01 = input_buf[0][in_row_group_ctr * 2 + 1];
+  inptr00 = input_buf[0][in_row_group_ctr*2];
+  inptr01 = input_buf[0][in_row_group_ctr*2 + 1];
  inptr1 = input_buf[1][in_row_group_ctr];
  inptr2 = input_buf[2][in_row_group_ctr];
  outptr0 = output_buf[0];
@@ -120,13 +122,13 @@ h2v2_merged_upsample_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
  /* Loop for each group of output pixels */
  for (col = cinfo->output_width >> 1; col > 0; col--) {
    /* Do the chroma part of the calculation */
-    cb = *inptr1++;
-    cr = *inptr2++;
+    cb = GETJSAMPLE(*inptr1++);
+    cr = GETJSAMPLE(*inptr2++);
    cred = Crrtab[cr];
-    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+    cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
    cblue = Cbbtab[cb];
    /* Fetch 4 Y values and emit 4 pixels */
-    y  = *inptr00++;
+    y  = GETJSAMPLE(*inptr00++);
    outptr0[RGB_RED] =   range_limit[y + cred];
    outptr0[RGB_GREEN] = range_limit[y + cgreen];
    outptr0[RGB_BLUE] =  range_limit[y + cblue];
@@ -134,7 +136,7 @@ h2v2_merged_upsample_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
    outptr0[RGB_ALPHA] = 0xFF;
 #endif
    outptr0 += RGB_PIXELSIZE;
-    y  = *inptr00++;
+    y  = GETJSAMPLE(*inptr00++);
    outptr0[RGB_RED] =   range_limit[y + cred];
    outptr0[RGB_GREEN] = range_limit[y + cgreen];
    outptr0[RGB_BLUE] =  range_limit[y + cblue];
@@ -142,7 +144,7 @@ h2v2_merged_upsample_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
    outptr0[RGB_ALPHA] = 0xFF;
 #endif
    outptr0 += RGB_PIXELSIZE;
-    y  = *inptr01++;
+    y  = GETJSAMPLE(*inptr01++);
    outptr1[RGB_RED] =   range_limit[y + cred];
    outptr1[RGB_GREEN] = range_limit[y + cgreen];
    outptr1[RGB_BLUE] =  range_limit[y + cblue];
@@ -150,7 +152,7 @@ h2v2_merged_upsample_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
    outptr1[RGB_ALPHA] = 0xFF;
 #endif
    outptr1 += RGB_PIXELSIZE;
-    y  = *inptr01++;
+    y  = GETJSAMPLE(*inptr01++);
    outptr1[RGB_RED] =   range_limit[y + cred];
    outptr1[RGB_GREEN] = range_limit[y + cgreen];
    outptr1[RGB_BLUE] =  range_limit[y + cblue];
@@ -161,19 +163,19 @@ h2v2_merged_upsample_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
  }
  /* If image width is odd, do the last output column separately */
  if (cinfo->output_width & 1) {
-    cb = *inptr1;
-    cr = *inptr2;
+    cb = GETJSAMPLE(*inptr1);
+    cr = GETJSAMPLE(*inptr2);
    cred = Crrtab[cr];
-    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+    cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
    cblue = Cbbtab[cb];
-    y  = *inptr00;
+    y  = GETJSAMPLE(*inptr00);
    outptr0[RGB_RED] =   range_limit[y + cred];
    outptr0[RGB_GREEN] = range_limit[y + cgreen];
    outptr0[RGB_BLUE] =  range_limit[y + cblue];
 #ifdef RGB_ALPHA
    outptr0[RGB_ALPHA] = 0xFF;
 #endif
-    y  = *inptr01;
+    y  = GETJSAMPLE(*inptr01);
    outptr1[RGB_RED] =   range_limit[y + cred];
    outptr1[RGB_GREEN] = range_limit[y + cgreen];
    outptr1[RGB_BLUE] =  range_limit[y + cblue];
@@ -4,7 +4,7 @@
 * This file was part of the Independent JPEG Group's software:
 * Copyright (C) 1995-1997, Thomas G. Lane.
 * libjpeg-turbo Modifications:
- * Copyright (C) 2015-2016, 2018-2021, D. R. Commander.
+ * Copyright (C) 2015-2016, D. R. Commander.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
 *
@@ -15,16 +15,12 @@
 * up to the start of the current MCU.  To do this, we copy state variables
 * into local working storage, and update them back to the permanent
 * storage only upon successful completion of an MCU.
- *
- * NOTE: All referenced figures are from
- * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994.
 */

 #define JPEG_INTERNALS
 #include "jinclude.h"
 #include "jpeglib.h"
 #include "jdhuff.h"             /* Declarations shared with jdhuff.c */
-#include <limits.h>


 #ifdef D_PROGRESSIVE_SUPPORTED
@@ -41,6 +37,25 @@ typedef struct {
  int last_dc_val[MAX_COMPS_IN_SCAN];   /* last DC coef for each component */
 } savable_state;

+/* This macro is to work around compilers with missing or broken
+ * structure assignment.  You'll need to fix this code if you have
+ * such a compiler and you change MAX_COMPS_IN_SCAN.
+ */
+
+#ifndef NO_STRUCT_ASSIGN
+#define ASSIGN_STATE(dest,src)  ((dest) = (src))
+#else
+#if MAX_COMPS_IN_SCAN == 4
+#define ASSIGN_STATE(dest,src)  \
+        ((dest).EOBRUN = (src).EOBRUN, \
+         (dest).last_dc_val[0] = (src).last_dc_val[0], \
+         (dest).last_dc_val[1] = (src).last_dc_val[1], \
+         (dest).last_dc_val[2] = (src).last_dc_val[2], \
+         (dest).last_dc_val[3] = (src).last_dc_val[3])
+#endif
+#endif
+
+
 typedef struct {
  struct jpeg_entropy_decoder pub; /* public fields */

@@ -62,14 +77,14 @@ typedef struct {
 typedef phuff_entropy_decoder *phuff_entropy_ptr;

 /* Forward declarations */
-METHODDEF(boolean) decode_mcu_DC_first(j_decompress_ptr cinfo,
-                                       JBLOCKROW *MCU_data);
-METHODDEF(boolean) decode_mcu_AC_first(j_decompress_ptr cinfo,
-                                       JBLOCKROW *MCU_data);
-METHODDEF(boolean) decode_mcu_DC_refine(j_decompress_ptr cinfo,
+METHODDEF(boolean) decode_mcu_DC_first (j_decompress_ptr cinfo,
                                        JBLOCKROW *MCU_data);
-METHODDEF(boolean) decode_mcu_AC_refine(j_decompress_ptr cinfo,
+METHODDEF(boolean) decode_mcu_AC_first (j_decompress_ptr cinfo,
                                        JBLOCKROW *MCU_data);
+METHODDEF(boolean) decode_mcu_DC_refine (j_decompress_ptr cinfo,
+                                         JBLOCKROW *MCU_data);
+METHODDEF(boolean) decode_mcu_AC_refine (j_decompress_ptr cinfo,
+                                         JBLOCKROW *MCU_data);


 /*
@@ -77,13 +92,13 @@ METHODDEF(boolean) decode_mcu_AC_refine(j_decompress_ptr cinfo,
 */

 METHODDEF(void)
-start_pass_phuff_decoder(j_decompress_ptr cinfo)
+start_pass_phuff_decoder (j_decompress_ptr cinfo)
 {
-  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
  boolean is_DC_band, bad;
  int ci, coefi, tbl;
  d_derived_tbl **pdtbl;
-  int *coef_bit_ptr, *prev_coef_bit_ptr;
+  int *coef_bit_ptr;
  jpeg_component_info *compptr;

  is_DC_band = (cinfo->Ss == 0);
@@ -103,7 +118,7 @@ start_pass_phuff_decoder(j_decompress_ptr cinfo)
  }
  if (cinfo->Ah != 0) {
    /* Successive approximation refinement scan: must have Al = Ah-1. */
-    if (cinfo->Al != cinfo->Ah - 1)
+    if (cinfo->Al != cinfo->Ah-1)
      bad = TRUE;
  }
  if (cinfo->Al > 13)           /* need not check for < 0 */
@@ -123,16 +138,9 @@ start_pass_phuff_decoder(j_decompress_ptr cinfo)
   */
  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
    int cindex = cinfo->cur_comp_info[ci]->component_index;
-    coef_bit_ptr = &cinfo->coef_bits[cindex][0];
-    prev_coef_bit_ptr = &cinfo->coef_bits[cindex + cinfo->num_components][0];
+    coef_bit_ptr = & cinfo->coef_bits[cindex][0];
    if (!is_DC_band && coef_bit_ptr[0] < 0) /* AC without prior DC scan */
      WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, 0);
-    for (coefi = MIN(cinfo->Ss, 1); coefi <= MAX(cinfo->Se, 9); coefi++) {
-      if (cinfo->input_scan_number > 1)
-        prev_coef_bit_ptr[coefi] = coef_bit_ptr[coefi];
-      else
-        prev_coef_bit_ptr[coefi] = 0;
-    }
    for (coefi = cinfo->Ss; coefi <= cinfo->Se; coefi++) {
      int expected = (coef_bit_ptr[coefi] < 0) ? 0 : coef_bit_ptr[coefi];
      if (cinfo->Ah != expected)
@@ -197,26 +205,22 @@ start_pass_phuff_decoder(j_decompress_ptr cinfo)
 #define AVOID_TABLES
 #ifdef AVOID_TABLES

-#define NEG_1  ((unsigned)-1)
-#define HUFF_EXTEND(x, s) \
-  ((x) < (1 << ((s) - 1)) ? (x) + (((NEG_1) << (s)) + 1) : (x))
+#define NEG_1 ((unsigned)-1)
+#define HUFF_EXTEND(x,s)  ((x) < (1<<((s)-1)) ? (x) + (((NEG_1)<<(s)) + 1) : (x))

 #else

-#define HUFF_EXTEND(x, s) \
-  ((x) < extend_test[s] ? (x) + extend_offset[s] : (x))
+#define HUFF_EXTEND(x,s)  ((x) < extend_test[s] ? (x) + extend_offset[s] : (x))

-static const int extend_test[16] = {   /* entry n is 2**(n-1) */
-  0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
-  0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000
-};
+static const int extend_test[16] =   /* entry n is 2**(n-1) */
+  { 0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
+    0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000 };

-static const int extend_offset[16] = { /* entry n is (-1 << n) + 1 */
-  0, ((-1) << 1) + 1, ((-1) << 2) + 1, ((-1) << 3) + 1, ((-1) << 4) + 1,
-  ((-1) << 5) + 1, ((-1) << 6) + 1, ((-1) << 7) + 1, ((-1) << 8) + 1,
-  ((-1) << 9) + 1, ((-1) << 10) + 1, ((-1) << 11) + 1, ((-1) << 12) + 1,
-  ((-1) << 13) + 1, ((-1) << 14) + 1, ((-1) << 15) + 1
-};
+static const int extend_offset[16] = /* entry n is (-1 << n) + 1 */
+  { 0, ((-1)<<1) + 1, ((-1)<<2) + 1, ((-1)<<3) + 1, ((-1)<<4) + 1,
+    ((-1)<<5) + 1, ((-1)<<6) + 1, ((-1)<<7) + 1, ((-1)<<8) + 1,
+    ((-1)<<9) + 1, ((-1)<<10) + 1, ((-1)<<11) + 1, ((-1)<<12) + 1,
+    ((-1)<<13) + 1, ((-1)<<14) + 1, ((-1)<<15) + 1 };

 #endif /* AVOID_TABLES */

@@ -227,9 +231,9 @@ static const int extend_offset[16] = { /* entry n is (-1 << n) + 1 */
 */

 LOCAL(boolean)
-process_restart(j_decompress_ptr cinfo)
+process_restart (j_decompress_ptr cinfo)
 {
-  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
  int ci;

  /* Throw away any unused bits remaining in bit buffer; */
@@ -238,7 +242,7 @@ process_restart(j_decompress_ptr cinfo)
  entropy->bitstate.bits_left = 0;

  /* Advance past the RSTn marker */
-  if (!(*cinfo->marker->read_restart_marker) (cinfo))
+  if (! (*cinfo->marker->read_restart_marker) (cinfo))
    return FALSE;

  /* Re-initialize DC predictions to 0 */
@@ -285,9 +289,9 @@ process_restart(j_decompress_ptr cinfo)
 */

 METHODDEF(boolean)
-decode_mcu_DC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 {
-  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
  int Al = cinfo->Al;
  register int s, r;
  int blkn, ci;
@@ -300,18 +304,18 @@ decode_mcu_DC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
  /* Process restart marker if needed; may have to suspend */
  if (cinfo->restart_interval) {
    if (entropy->restarts_to_go == 0)
-      if (!process_restart(cinfo))
+      if (! process_restart(cinfo))
        return FALSE;
  }

  /* If we've run out of data, just leave the MCU set to zeroes.
   * This way, we return uniform gray for the remainder of the segment.
   */
-  if (!entropy->pub.insufficient_data) {
+  if (! entropy->pub.insufficient_data) {

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

    /* Outer loop handles each block in the MCU */

@@ -332,24 +336,19 @@ decode_mcu_DC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
      }

      /* Convert DC difference to actual value, update last_dc_val */
-      if ((state.last_dc_val[ci] >= 0 &&
-           s > INT_MAX - state.last_dc_val[ci]) ||
-          (state.last_dc_val[ci] < 0 && s < INT_MIN - state.last_dc_val[ci]))
-        ERREXIT(cinfo, JERR_BAD_DCT_COEF);
      s += state.last_dc_val[ci];
      state.last_dc_val[ci] = s;
      /* Scale and output the coefficient (assumes jpeg_natural_order[0]=0) */
-      (*block)[0] = (JCOEF)LEFT_SHIFT(s, Al);
+      (*block)[0] = (JCOEF) LEFT_SHIFT(s, Al);
    }

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

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

  return TRUE;
 }
@@ -361,9 +360,9 @@ decode_mcu_DC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 */

 METHODDEF(boolean)
-decode_mcu_AC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 {
-  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
  int Se = cinfo->Se;
  int Al = cinfo->Al;
  register int s, k, r;
@@ -375,14 +374,14 @@ decode_mcu_AC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
  /* Process restart marker if needed; may have to suspend */
  if (cinfo->restart_interval) {
    if (entropy->restarts_to_go == 0)
-      if (!process_restart(cinfo))
+      if (! process_restart(cinfo))
        return FALSE;
  }

  /* If we've run out of data, just leave the MCU set to zeroes.
   * This way, we return uniform gray for the remainder of the segment.
   */
-  if (!entropy->pub.insufficient_data) {
+  if (! entropy->pub.insufficient_data) {

    /* Load up working state.
     * We can avoid loading/saving bitread state if in an EOB run.
@@ -394,7 +393,7 @@ decode_mcu_AC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
    if (EOBRUN > 0)             /* 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);
      block = MCU_data[0];
      tbl = entropy->ac_derived_tbl;

@@ -408,7 +407,7 @@ decode_mcu_AC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
          r = GET_BITS(s);
          s = HUFF_EXTEND(r, s);
          /* Scale and output coefficient in natural (dezigzagged) order */
-          (*block)[jpeg_natural_order[k]] = (JCOEF)LEFT_SHIFT(s, Al);
+          (*block)[jpeg_natural_order[k]] = (JCOEF) LEFT_SHIFT(s, Al);
        } else {
          if (r == 15) {        /* ZRL */
            k += 15;            /* skip 15 zeroes in band */
@@ -425,7 +424,7 @@ 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 */
@@ -433,8 +432,7 @@ decode_mcu_AC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
  }

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

  return TRUE;
 }
@@ -447,9 +445,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)
+decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 {
-  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
  int p1 = 1 << cinfo->Al;      /* 1 in the bit position being coded */
  int blkn;
  JBLOCKROW block;
@@ -458,7 +456,7 @@ decode_mcu_DC_refine(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
  /* Process restart marker if needed; may have to suspend */
  if (cinfo->restart_interval) {
    if (entropy->restarts_to_go == 0)
-      if (!process_restart(cinfo))
+      if (! process_restart(cinfo))
        return FALSE;
  }

@@ -467,7 +465,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);

  /* Outer loop handles each block in the MCU */

@@ -482,11 +480,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 (no-op if not using restarts) */
-  if (cinfo->restart_interval)
-    entropy->restarts_to_go--;
+  entropy->restarts_to_go--;

  return TRUE;
 }
@@ -497,9 +494,9 @@ decode_mcu_DC_refine(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 */

 METHODDEF(boolean)
-decode_mcu_AC_refine(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 {
-  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
  int Se = cinfo->Se;
  int p1 = 1 << cinfo->Al;        /* 1 in the bit position being coded */
  int m1 = (NEG_1) << cinfo->Al;  /* -1 in the bit position being coded */
@@ -515,16 +512,16 @@ decode_mcu_AC_refine(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
  /* Process restart marker if needed; may have to suspend */
  if (cinfo->restart_interval) {
    if (entropy->restarts_to_go == 0)
-      if (!process_restart(cinfo))
+      if (! process_restart(cinfo))
        return FALSE;
  }

  /* If we've run out of data, don't modify the MCU.
   */
-  if (!entropy->pub.insufficient_data) {
+  if (! entropy->pub.insufficient_data) {

    /* 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 */
@@ -592,7 +589,7 @@ decode_mcu_AC_refine(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
        if (s) {
          int pos = jpeg_natural_order[k];
          /* Output newly nonzero coefficient */
-          (*block)[pos] = (JCOEF)s;
+          (*block)[pos] = (JCOEF) s;
          /* Remember its position in case we have to suspend */
          newnz_pos[num_newnz++] = pos;
        }
@@ -624,13 +621,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 (no-op if not using restarts) */
-  if (cinfo->restart_interval)
-    entropy->restarts_to_go--;
+  entropy->restarts_to_go--;

  return TRUE;

@@ -648,16 +644,16 @@ undoit:
 */

 GLOBAL(void)
-jinit_phuff_decoder(j_decompress_ptr cinfo)
+jinit_phuff_decoder (j_decompress_ptr cinfo)
 {
  phuff_entropy_ptr entropy;
  int *coef_bit_ptr;
  int ci, i;

  entropy = (phuff_entropy_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                sizeof(phuff_entropy_decoder));
-  cinfo->entropy = (struct jpeg_entropy_decoder *)entropy;
+  cinfo->entropy = (struct jpeg_entropy_decoder *) entropy;
  entropy->pub.start_pass = start_pass_phuff_decoder;

  /* Mark derived tables unallocated */
@@ -667,10 +663,9 @@ jinit_phuff_decoder(j_decompress_ptr cinfo)

  /* Create progression status table */
  cinfo->coef_bits = (int (*)[DCTSIZE2])
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                cinfo->num_components * 2 * DCTSIZE2 *
-                                sizeof(int));
-  coef_bit_ptr = &cinfo->coef_bits[0][0];
+    (*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++)
      *coef_bit_ptr++ = -1;
@@ -46,28 +46,22 @@ typedef my_post_controller *my_post_ptr;


 /* Forward declarations */
-METHODDEF(void) post_process_1pass(j_decompress_ptr cinfo,
-                                   JSAMPIMAGE input_buf,
-                                   JDIMENSION *in_row_group_ctr,
-                                   JDIMENSION in_row_groups_avail,
-                                   JSAMPARRAY output_buf,
-                                   JDIMENSION *out_row_ctr,
-                                   JDIMENSION out_rows_avail);
+METHODDEF(void) post_process_1pass
+        (j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+         JDIMENSION *in_row_group_ctr, JDIMENSION in_row_groups_avail,
+         JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+         JDIMENSION out_rows_avail);
 #ifdef QUANT_2PASS_SUPPORTED
-METHODDEF(void) post_process_prepass(j_decompress_ptr cinfo,
-                                     JSAMPIMAGE input_buf,
-                                     JDIMENSION *in_row_group_ctr,
-                                     JDIMENSION in_row_groups_avail,
-                                     JSAMPARRAY output_buf,
-                                     JDIMENSION *out_row_ctr,
-                                     JDIMENSION out_rows_avail);
-METHODDEF(void) post_process_2pass(j_decompress_ptr cinfo,
-                                   JSAMPIMAGE input_buf,
-                                   JDIMENSION *in_row_group_ctr,
-                                   JDIMENSION in_row_groups_avail,
-                                   JSAMPARRAY output_buf,
-                                   JDIMENSION *out_row_ctr,
-                                   JDIMENSION out_rows_avail);
+METHODDEF(void) post_process_prepass
+        (j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+         JDIMENSION *in_row_group_ctr, JDIMENSION in_row_groups_avail,
+         JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+         JDIMENSION out_rows_avail);
+METHODDEF(void) post_process_2pass
+        (j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+         JDIMENSION *in_row_group_ctr, JDIMENSION in_row_groups_avail,
+         JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+         JDIMENSION out_rows_avail);
 #endif


@@ -76,9 +70,9 @@ METHODDEF(void) post_process_2pass(j_decompress_ptr cinfo,
 */

 METHODDEF(void)
-start_pass_dpost(j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
+start_pass_dpost (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
 {
-  my_post_ptr post = (my_post_ptr)cinfo->post;
+  my_post_ptr post = (my_post_ptr) cinfo->post;

  switch (pass_mode) {
  case JBUF_PASS_THRU:
@@ -91,8 +85,8 @@ start_pass_dpost(j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
       */
      if (post->buffer == NULL) {
        post->buffer = (*cinfo->mem->access_virt_sarray)
-          ((j_common_ptr)cinfo, post->whole_image,
-           (JDIMENSION)0, post->strip_height, TRUE);
+          ((j_common_ptr) cinfo, post->whole_image,
+           (JDIMENSION) 0, post->strip_height, TRUE);
      }
    } else {
      /* For single-pass processing without color quantization,
@@ -129,12 +123,13 @@ start_pass_dpost(j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
 */

 METHODDEF(void)
-post_process_1pass(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                   JDIMENSION *in_row_group_ctr,
-                   JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf,
-                   JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
+post_process_1pass (j_decompress_ptr cinfo,
+                    JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+                    JDIMENSION in_row_groups_avail,
+                    JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+                    JDIMENSION out_rows_avail)
 {
-  my_post_ptr post = (my_post_ptr)cinfo->post;
+  my_post_ptr post = (my_post_ptr) cinfo->post;
  JDIMENSION num_rows, max_rows;

  /* Fill the buffer, but not more than what we can dump out in one go. */
@@ -143,13 +138,12 @@ post_process_1pass(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
  if (max_rows > post->strip_height)
    max_rows = post->strip_height;
  num_rows = 0;
-  (*cinfo->upsample->upsample) (cinfo, input_buf, in_row_group_ctr,
-                                in_row_groups_avail, post->buffer, &num_rows,
-                                max_rows);
+  (*cinfo->upsample->upsample) (cinfo,
+                input_buf, in_row_group_ctr, in_row_groups_avail,
+                post->buffer, &num_rows, max_rows);
  /* Quantize and emit data. */
-  (*cinfo->cquantize->color_quantize) (cinfo, post->buffer,
-                                       output_buf + *out_row_ctr,
-                                       (int)num_rows);
+  (*cinfo->cquantize->color_quantize) (cinfo,
+                post->buffer, output_buf + *out_row_ctr, (int) num_rows);
  *out_row_ctr += num_rows;
 }

@@ -161,33 +155,34 @@ post_process_1pass(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 */

 METHODDEF(void)
-post_process_prepass(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                     JDIMENSION *in_row_group_ctr,
-                     JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf,
-                     JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
+post_process_prepass (j_decompress_ptr cinfo,
+                      JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+                      JDIMENSION in_row_groups_avail,
+                      JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+                      JDIMENSION out_rows_avail)
 {
-  my_post_ptr post = (my_post_ptr)cinfo->post;
+  my_post_ptr post = (my_post_ptr) cinfo->post;
  JDIMENSION old_next_row, num_rows;

  /* Reposition virtual buffer if at start of strip. */
  if (post->next_row == 0) {
    post->buffer = (*cinfo->mem->access_virt_sarray)
-        ((j_common_ptr)cinfo, post->whole_image,
+        ((j_common_ptr) cinfo, post->whole_image,
         post->starting_row, post->strip_height, TRUE);
  }

  /* Upsample some data (up to a strip height's worth). */
  old_next_row = post->next_row;
-  (*cinfo->upsample->upsample) (cinfo, input_buf, in_row_group_ctr,
-                                in_row_groups_avail, post->buffer,
-                                &post->next_row, post->strip_height);
+  (*cinfo->upsample->upsample) (cinfo,
+                input_buf, in_row_group_ctr, in_row_groups_avail,
+                post->buffer, &post->next_row, post->strip_height);

  /* Allow quantizer to scan new data.  No data is emitted, */
  /* but we advance out_row_ctr so outer loop can tell when we're done. */
  if (post->next_row > old_next_row) {
    num_rows = post->next_row - old_next_row;
    (*cinfo->cquantize->color_quantize) (cinfo, post->buffer + old_next_row,
-                                         (JSAMPARRAY)NULL, (int)num_rows);
+                                         (JSAMPARRAY) NULL, (int) num_rows);
    *out_row_ctr += num_rows;
  }

@@ -204,18 +199,19 @@ post_process_prepass(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 */

 METHODDEF(void)
-post_process_2pass(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-                   JDIMENSION *in_row_group_ctr,
-                   JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf,
-                   JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
+post_process_2pass (j_decompress_ptr cinfo,
+                    JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+                    JDIMENSION in_row_groups_avail,
+                    JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+                    JDIMENSION out_rows_avail)
 {
-  my_post_ptr post = (my_post_ptr)cinfo->post;
+  my_post_ptr post = (my_post_ptr) cinfo->post;
  JDIMENSION num_rows, max_rows;

  /* Reposition virtual buffer if at start of strip. */
  if (post->next_row == 0) {
    post->buffer = (*cinfo->mem->access_virt_sarray)
-        ((j_common_ptr)cinfo, post->whole_image,
+        ((j_common_ptr) cinfo, post->whole_image,
         post->starting_row, post->strip_height, FALSE);
  }

@@ -230,9 +226,9 @@ post_process_2pass(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
    num_rows = max_rows;

  /* Quantize and emit data. */
-  (*cinfo->cquantize->color_quantize) (cinfo, post->buffer + post->next_row,
-                                       output_buf + *out_row_ctr,
-                                       (int)num_rows);
+  (*cinfo->cquantize->color_quantize) (cinfo,
+                post->buffer + post->next_row, output_buf + *out_row_ctr,
+                (int) num_rows);
  *out_row_ctr += num_rows;

  /* Advance if we filled the strip. */
@@ -251,14 +247,14 @@ post_process_2pass(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 */

 GLOBAL(void)
-jinit_d_post_controller(j_decompress_ptr cinfo, boolean need_full_buffer)
+jinit_d_post_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
 {
  my_post_ptr post;

  post = (my_post_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                sizeof(my_post_controller));
-  cinfo->post = (struct jpeg_d_post_controller *)post;
+  cinfo->post = (struct jpeg_d_post_controller *) post;
  post->pub.start_pass = start_pass_dpost;
  post->whole_image = NULL;     /* flag for no virtual arrays */
  post->buffer = NULL;          /* flag for no strip buffer */
@@ -269,16 +265,16 @@ jinit_d_post_controller(j_decompress_ptr cinfo, boolean need_full_buffer)
     * an efficient number of rows for upsampling to return.
     * (In the presence of output rescaling, we might want to be smarter?)
     */
-    post->strip_height = (JDIMENSION)cinfo->max_v_samp_factor;
+    post->strip_height = (JDIMENSION) cinfo->max_v_samp_factor;
    if (need_full_buffer) {
      /* Two-pass color quantization: need full-image storage. */
      /* We round up the number of rows to a multiple of the strip height. */
 #ifdef QUANT_2PASS_SUPPORTED
      post->whole_image = (*cinfo->mem->request_virt_sarray)
-        ((j_common_ptr)cinfo, JPOOL_IMAGE, FALSE,
+        ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
         cinfo->output_width * cinfo->out_color_components,
-         (JDIMENSION)jround_up((long)cinfo->output_height,
-                               (long)post->strip_height),
+         (JDIMENSION) jround_up((long) cinfo->output_height,
+                                (long) post->strip_height),
         post->strip_height);
 #else
      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
@@ -286,7 +282,7 @@ jinit_d_post_controller(j_decompress_ptr cinfo, boolean need_full_buffer)
    } else {
      /* One-pass color quantization: just make a strip buffer. */
      post->buffer = (*cinfo->mem->alloc_sarray)
-        ((j_common_ptr)cinfo, JPOOL_IMAGE,
+        ((j_common_ptr) cinfo, JPOOL_IMAGE,
         cinfo->output_width * cinfo->out_color_components,
         post->strip_height);
    }
@@ -8,7 +8,6 @@
 * Copyright (C) 2010, 2015-2016, D. R. Commander.
 * Copyright (C) 2014, MIPS Technologies, Inc., California.
 * Copyright (C) 2015, Google, Inc.
- * Copyright (C) 2019-2020, Arm Limited.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
 *
@@ -37,9 +36,9 @@
 */

 METHODDEF(void)
-start_pass_upsample(j_decompress_ptr cinfo)
+start_pass_upsample (j_decompress_ptr cinfo)
 {
-  my_upsample_ptr upsample = (my_upsample_ptr)cinfo->upsample;
+  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;

  /* Mark the conversion buffer empty */
  upsample->next_row_out = cinfo->max_v_samp_factor;
@@ -57,12 +56,13 @@ start_pass_upsample(j_decompress_ptr cinfo)
 */

 METHODDEF(void)
-sep_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
-             JDIMENSION *in_row_group_ctr, JDIMENSION in_row_groups_avail,
-             JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
-             JDIMENSION out_rows_avail)
+sep_upsample (j_decompress_ptr cinfo,
+              JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+              JDIMENSION in_row_groups_avail,
+              JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+              JDIMENSION out_rows_avail)
 {
-  my_upsample_ptr upsample = (my_upsample_ptr)cinfo->upsample;
+  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
  int ci;
  jpeg_component_info *compptr;
  JDIMENSION num_rows;
@@ -84,7 +84,7 @@ sep_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
  /* Color-convert and emit rows */

  /* How many we have in the buffer: */
-  num_rows = (JDIMENSION)(cinfo->max_v_samp_factor - upsample->next_row_out);
+  num_rows = (JDIMENSION) (cinfo->max_v_samp_factor - upsample->next_row_out);
  /* Not more than the distance to the end of the image.  Need this test
   * in case the image height is not a multiple of max_v_samp_factor:
   */
@@ -96,8 +96,9 @@ sep_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
    num_rows = out_rows_avail;

  (*cinfo->cconvert->color_convert) (cinfo, upsample->color_buf,
-                                     (JDIMENSION)upsample->next_row_out,
-                                     output_buf + *out_row_ctr, (int)num_rows);
+                                     (JDIMENSION) upsample->next_row_out,
+                                     output_buf + *out_row_ctr,
+                                     (int) num_rows);

  /* Adjust counts */
  *out_row_ctr += num_rows;
@@ -123,8 +124,8 @@ sep_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 */

 METHODDEF(void)
-fullsize_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
-                  JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+fullsize_upsample (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                   JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
 {
  *output_data_ptr = input_data;
 }
@@ -136,8 +137,8 @@ fullsize_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
 */

 METHODDEF(void)
-noop_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
-              JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+noop_upsample (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+               JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
 {
  *output_data_ptr = NULL;      /* safety check */
 }
@@ -155,10 +156,10 @@ noop_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
 */

 METHODDEF(void)
-int_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
-             JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+int_upsample (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+              JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
 {
-  my_upsample_ptr upsample = (my_upsample_ptr)cinfo->upsample;
+  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
  JSAMPARRAY output_data = *output_data_ptr;
  register JSAMPROW inptr, outptr;
  register JSAMPLE invalue;
@@ -177,15 +178,15 @@ int_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
    outptr = output_data[outrow];
    outend = outptr + cinfo->output_width;
    while (outptr < outend) {
-      invalue = *inptr++;
+      invalue = *inptr++;       /* don't need GETJSAMPLE() here */
      for (h = h_expand; h > 0; h--) {
        *outptr++ = invalue;
      }
    }
    /* Generate any additional output rows by duplicating the first one */
    if (v_expand > 1) {
-      jcopy_sample_rows(output_data, outrow, output_data, outrow + 1,
-                        v_expand - 1, cinfo->output_width);
+      jcopy_sample_rows(output_data, outrow, output_data, outrow+1,
+                        v_expand-1, cinfo->output_width);
    }
    inrow++;
    outrow += v_expand;
@@ -199,8 +200,8 @@ int_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
 */

 METHODDEF(void)
-h2v1_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
-              JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+h2v1_upsample (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+               JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
 {
  JSAMPARRAY output_data = *output_data_ptr;
  register JSAMPROW inptr, outptr;
@@ -213,7 +214,7 @@ h2v1_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
    outptr = output_data[inrow];
    outend = outptr + cinfo->output_width;
    while (outptr < outend) {
-      invalue = *inptr++;
+      invalue = *inptr++;       /* don't need GETJSAMPLE() here */
      *outptr++ = invalue;
      *outptr++ = invalue;
    }
@@ -227,8 +228,8 @@ h2v1_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
 */

 METHODDEF(void)
-h2v2_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
-              JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+h2v2_upsample (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+               JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
 {
  JSAMPARRAY output_data = *output_data_ptr;
  register JSAMPROW inptr, outptr;
@@ -242,12 +243,12 @@ h2v2_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
    outptr = output_data[outrow];
    outend = outptr + cinfo->output_width;
    while (outptr < outend) {
-      invalue = *inptr++;
+      invalue = *inptr++;       /* don't need GETJSAMPLE() here */
      *outptr++ = invalue;
      *outptr++ = invalue;
    }
-    jcopy_sample_rows(output_data, outrow, output_data, outrow + 1, 1,
-                      cinfo->output_width);
+    jcopy_sample_rows(output_data, outrow, output_data, outrow+1,
+                      1, cinfo->output_width);
    inrow++;
    outrow += 2;
  }
@@ -270,8 +271,8 @@ h2v2_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
 */

 METHODDEF(void)
-h2v1_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
-                    JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+h2v1_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                     JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
 {
  JSAMPARRAY output_data = *output_data_ptr;
  register JSAMPROW inptr, outptr;
@@ -283,21 +284,21 @@ h2v1_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
    inptr = input_data[inrow];
    outptr = output_data[inrow];
    /* Special case for first column */
-    invalue = *inptr++;
-    *outptr++ = (JSAMPLE)invalue;
-    *outptr++ = (JSAMPLE)((invalue * 3 + inptr[0] + 2) >> 2);
+    invalue = GETJSAMPLE(*inptr++);
+    *outptr++ = (JSAMPLE) invalue;
+    *outptr++ = (JSAMPLE) ((invalue * 3 + GETJSAMPLE(*inptr) + 2) >> 2);

    for (colctr = compptr->downsampled_width - 2; colctr > 0; colctr--) {
      /* General case: 3/4 * nearer pixel + 1/4 * further pixel */
-      invalue = (*inptr++) * 3;
-      *outptr++ = (JSAMPLE)((invalue + inptr[-2] + 1) >> 2);
-      *outptr++ = (JSAMPLE)((invalue + inptr[0] + 2) >> 2);
+      invalue = GETJSAMPLE(*inptr++) * 3;
+      *outptr++ = (JSAMPLE) ((invalue + GETJSAMPLE(inptr[-2]) + 1) >> 2);
+      *outptr++ = (JSAMPLE) ((invalue + GETJSAMPLE(*inptr) + 2) >> 2);
    }

    /* Special case for last column */
-    invalue = *inptr;
-    *outptr++ = (JSAMPLE)((invalue * 3 + inptr[-1] + 1) >> 2);
-    *outptr++ = (JSAMPLE)invalue;
+    invalue = GETJSAMPLE(*inptr);
+    *outptr++ = (JSAMPLE) ((invalue * 3 + GETJSAMPLE(inptr[-1]) + 1) >> 2);
+    *outptr++ = (JSAMPLE) invalue;
  }
 }

@@ -310,15 +311,15 @@ h2v1_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
 */

 METHODDEF(void)
-h1v2_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
-                    JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+h1v2_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                     JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
 {
  JSAMPARRAY output_data = *output_data_ptr;
  JSAMPROW inptr0, inptr1, outptr;
 #if BITS_IN_JSAMPLE == 8
-  int thiscolsum, bias;
+  int thiscolsum;
 #else
-  JLONG thiscolsum, bias;
+  JLONG thiscolsum;
 #endif
  JDIMENSION colctr;
  int inrow, outrow, v;
@@ -328,18 +329,15 @@ h1v2_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
    for (v = 0; v < 2; v++) {
      /* inptr0 points to nearest input row, inptr1 points to next nearest */
      inptr0 = input_data[inrow];
-      if (v == 0) {             /* next nearest is row above */
-        inptr1 = input_data[inrow - 1];
-        bias = 1;
-      } else {                  /* next nearest is row below */
-        inptr1 = input_data[inrow + 1];
-        bias = 2;
-      }
+      if (v == 0)               /* next nearest is row above */
+        inptr1 = input_data[inrow-1];
+      else                      /* next nearest is row below */
+        inptr1 = input_data[inrow+1];
      outptr = output_data[outrow++];

-      for (colctr = 0; colctr < compptr->downsampled_width; colctr++) {
-        thiscolsum = (*inptr0++) * 3 + (*inptr1++);
-        *outptr++ = (JSAMPLE)((thiscolsum + bias) >> 2);
+      for(colctr = 0; colctr < compptr->downsampled_width; colctr++) {
+        thiscolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++);
+        *outptr++ = (JSAMPLE) ((thiscolsum + 1) >> 2);
      }
    }
    inrow++;
@@ -356,8 +354,8 @@ h1v2_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
 */

 METHODDEF(void)
-h2v2_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
-                    JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+h2v2_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                     JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
 {
  JSAMPARRAY output_data = *output_data_ptr;
  register JSAMPROW inptr0, inptr1, outptr;
@@ -375,30 +373,30 @@ h2v2_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
      /* inptr0 points to nearest input row, inptr1 points to next nearest */
      inptr0 = input_data[inrow];
      if (v == 0)               /* next nearest is row above */
-        inptr1 = input_data[inrow - 1];
+        inptr1 = input_data[inrow-1];
      else                      /* next nearest is row below */
-        inptr1 = input_data[inrow + 1];
+        inptr1 = input_data[inrow+1];
      outptr = output_data[outrow++];

      /* Special case for first column */
-      thiscolsum = (*inptr0++) * 3 + (*inptr1++);
-      nextcolsum = (*inptr0++) * 3 + (*inptr1++);
-      *outptr++ = (JSAMPLE)((thiscolsum * 4 + 8) >> 4);
-      *outptr++ = (JSAMPLE)((thiscolsum * 3 + nextcolsum + 7) >> 4);
-      lastcolsum = thiscolsum;  thiscolsum = nextcolsum;
+      thiscolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++);
+      nextcolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++);
+      *outptr++ = (JSAMPLE) ((thiscolsum * 4 + 8) >> 4);
+      *outptr++ = (JSAMPLE) ((thiscolsum * 3 + nextcolsum + 7) >> 4);
+      lastcolsum = thiscolsum; thiscolsum = nextcolsum;

      for (colctr = compptr->downsampled_width - 2; colctr > 0; colctr--) {
        /* General case: 3/4 * nearer pixel + 1/4 * further pixel in each */
        /* dimension, thus 9/16, 3/16, 3/16, 1/16 overall */
-        nextcolsum = (*inptr0++) * 3 + (*inptr1++);
-        *outptr++ = (JSAMPLE)((thiscolsum * 3 + lastcolsum + 8) >> 4);
-        *outptr++ = (JSAMPLE)((thiscolsum * 3 + nextcolsum + 7) >> 4);
-        lastcolsum = thiscolsum;  thiscolsum = nextcolsum;
+        nextcolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++);
+        *outptr++ = (JSAMPLE) ((thiscolsum * 3 + lastcolsum + 8) >> 4);
+        *outptr++ = (JSAMPLE) ((thiscolsum * 3 + nextcolsum + 7) >> 4);
+        lastcolsum = thiscolsum; thiscolsum = nextcolsum;
      }

      /* Special case for last column */
-      *outptr++ = (JSAMPLE)((thiscolsum * 3 + lastcolsum + 8) >> 4);
-      *outptr++ = (JSAMPLE)((thiscolsum * 4 + 7) >> 4);
+      *outptr++ = (JSAMPLE) ((thiscolsum * 3 + lastcolsum + 8) >> 4);
+      *outptr++ = (JSAMPLE) ((thiscolsum * 4 + 7) >> 4);
    }
    inrow++;
  }
@@ -410,7 +408,7 @@ h2v2_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
 */

 GLOBAL(void)
-jinit_upsampler(j_decompress_ptr cinfo)
+jinit_upsampler (j_decompress_ptr cinfo)
 {
  my_upsample_ptr upsample;
  int ci;
@@ -420,14 +418,14 @@ jinit_upsampler(j_decompress_ptr cinfo)

  if (!cinfo->master->jinit_upsampler_no_alloc) {
    upsample = (my_upsample_ptr)
-      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                  sizeof(my_upsampler));
-    cinfo->upsample = (struct jpeg_upsampler *)upsample;
+    cinfo->upsample = (struct jpeg_upsampler *) upsample;
    upsample->pub.start_pass = start_pass_upsample;
    upsample->pub.upsample = sep_upsample;
    upsample->pub.need_context_rows = FALSE; /* until we find out differently */
  } else
-    upsample = (my_upsample_ptr)cinfo->upsample;
+    upsample = (my_upsample_ptr) cinfo->upsample;

  if (cinfo->CCIR601_sampling)  /* this isn't supported */
    ERREXIT(cinfo, JERR_CCIR601_NOTIMPL);
@@ -453,7 +451,7 @@ jinit_upsampler(j_decompress_ptr cinfo)
    v_out_group = cinfo->max_v_samp_factor;
    upsample->rowgroup_height[ci] = v_in_group; /* save for use later */
    need_buffer = TRUE;
-    if (!compptr->component_needed) {
+    if (! compptr->component_needed) {
      /* Don't bother to upsample an uninteresting component. */
      upsample->methods[ci] = noop_upsample;
      need_buffer = FALSE;
@@ -461,7 +459,8 @@ jinit_upsampler(j_decompress_ptr cinfo)
      /* Fullsize components can be processed without any work. */
      upsample->methods[ci] = fullsize_upsample;
      need_buffer = FALSE;
-    } else if (h_in_group * 2 == h_out_group && v_in_group == v_out_group) {
+    } else if (h_in_group * 2 == h_out_group &&
+               v_in_group == v_out_group) {
      /* Special cases for 2h1v upsampling */
      if (do_fancy && compptr->downsampled_width > 2) {
        if (jsimd_can_h2v1_fancy_upsample())
@@ -477,13 +476,7 @@ jinit_upsampler(j_decompress_ptr cinfo)
    } else if (h_in_group == h_out_group &&
               v_in_group * 2 == v_out_group && do_fancy) {
      /* Non-fancy upsampling is handled by the generic method */
-#if defined(__arm__) || defined(__aarch64__) || \
-    defined(_M_ARM) || defined(_M_ARM64)
-      if (jsimd_can_h1v2_fancy_upsample())
-        upsample->methods[ci] = jsimd_h1v2_fancy_upsample;
-      else
-#endif
-        upsample->methods[ci] = h1v2_fancy_upsample;
+      upsample->methods[ci] = h1v2_fancy_upsample;
      upsample->pub.need_context_rows = TRUE;
    } else if (h_in_group * 2 == h_out_group &&
               v_in_group * 2 == v_out_group) {
@@ -509,16 +502,16 @@ jinit_upsampler(j_decompress_ptr cinfo)
      else
 #endif
        upsample->methods[ci] = int_upsample;
-      upsample->h_expand[ci] = (UINT8)(h_out_group / h_in_group);
-      upsample->v_expand[ci] = (UINT8)(v_out_group / v_in_group);
+      upsample->h_expand[ci] = (UINT8) (h_out_group / h_in_group);
+      upsample->v_expand[ci] = (UINT8) (v_out_group / v_in_group);
    } else
      ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL);
    if (need_buffer && !cinfo->master->jinit_upsampler_no_alloc) {
      upsample->color_buf[ci] = (*cinfo->mem->alloc_sarray)
-        ((j_common_ptr)cinfo, JPOOL_IMAGE,
-         (JDIMENSION)jround_up((long)cinfo->output_width,
-                               (long)cinfo->max_h_samp_factor),
-         (JDIMENSION)cinfo->max_v_samp_factor);
+        ((j_common_ptr) cinfo, JPOOL_IMAGE,
+         (JDIMENSION) jround_up((long) cinfo->output_width,
+                                (long) cinfo->max_h_samp_factor),
+         (JDIMENSION) cinfo->max_v_samp_factor);
    }
  }
 }
@@ -3,8 +3,8 @@
 *
 * This file was part of the Independent JPEG Group's software:
 * Copyright (C) 1995-1997, Thomas G. Lane.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2020, D. R. Commander.
+ * It was modified by The libjpeg-turbo Project to include only code relevant
+ * to libjpeg-turbo.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
 *
@@ -16,11 +16,10 @@
 #define JPEG_INTERNALS
 #include "jinclude.h"
 #include "jpeglib.h"
-#include "jpegcomp.h"


 /* Forward declarations */
-LOCAL(void) transdecode_master_selection(j_decompress_ptr cinfo);
+LOCAL(void) transdecode_master_selection (j_decompress_ptr cinfo);


 /*
@@ -46,7 +45,7 @@ LOCAL(void) transdecode_master_selection(j_decompress_ptr cinfo);
 */

 GLOBAL(jvirt_barray_ptr *)
-jpeg_read_coefficients(j_decompress_ptr cinfo)
+jpeg_read_coefficients (j_decompress_ptr cinfo)
 {
  if (cinfo->global_state == DSTATE_READY) {
    /* First call: initialize active modules */
@@ -59,7 +58,7 @@ jpeg_read_coefficients(j_decompress_ptr cinfo)
      int retcode;
      /* Call progress monitor hook if present */
      if (cinfo->progress != NULL)
-        (*cinfo->progress->progress_monitor) ((j_common_ptr)cinfo);
+        (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
      /* Absorb some more input */
      retcode = (*cinfo->inputctl->consume_input) (cinfo);
      if (retcode == JPEG_SUSPENDED)
@@ -71,7 +70,7 @@ jpeg_read_coefficients(j_decompress_ptr cinfo)
          (retcode == JPEG_ROW_COMPLETED || retcode == JPEG_REACHED_SOS)) {
        if (++cinfo->progress->pass_counter >= cinfo->progress->pass_limit) {
          /* startup underestimated number of scans; ratchet up one scan */
-          cinfo->progress->pass_limit += (long)cinfo->total_iMCU_rows;
+          cinfo->progress->pass_limit += (long) cinfo->total_iMCU_rows;
        }
      }
    }
@@ -98,7 +97,7 @@ jpeg_read_coefficients(j_decompress_ptr cinfo)
 */

 LOCAL(void)
-transdecode_master_selection(j_decompress_ptr cinfo)
+transdecode_master_selection (j_decompress_ptr cinfo)
 {
  /* This is effectively a buffered-image operation. */
  cinfo->buffered_image = TRUE;
@@ -130,7 +129,7 @@ transdecode_master_selection(j_decompress_ptr cinfo)
  jinit_d_coef_controller(cinfo, TRUE);

  /* We can now tell the memory manager to allocate virtual arrays. */
-  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr)cinfo);
+  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);

  /* Initialize input side of decompressor to consume first scan. */
  (*cinfo->inputctl->start_input_pass) (cinfo);
@@ -149,7 +148,7 @@ transdecode_master_selection(j_decompress_ptr cinfo)
      nscans = 1;
    }
    cinfo->progress->pass_counter = 0L;
-    cinfo->progress->pass_limit = (long)cinfo->total_iMCU_rows * nscans;
+    cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows * nscans;
    cinfo->progress->completed_passes = 0;
    cinfo->progress->total_passes = 1;
  }
@@ -44,7 +44,7 @@
 * want to refer to it directly.
 */

-#define JMESSAGE(code, string)  string,
+#define JMESSAGE(code,string)   string ,

 const char * const jpeg_std_message_table[] = {
 #include "jerror.h"
@@ -66,7 +66,7 @@ const char * const jpeg_std_message_table[] = {
 */

 METHODDEF(void)
-error_exit(j_common_ptr cinfo)
+error_exit (j_common_ptr cinfo)
 {
  /* Always display the message */
  (*cinfo->err->output_message) (cinfo);
@@ -94,7 +94,7 @@ error_exit(j_common_ptr cinfo)
 */

 METHODDEF(void)
-output_message(j_common_ptr cinfo)
+output_message (j_common_ptr cinfo)
 {
  char buffer[JMSG_LENGTH_MAX];

@@ -124,7 +124,7 @@ output_message(j_common_ptr cinfo)
 */

 METHODDEF(void)
-emit_message(j_common_ptr cinfo, int msg_level)
+emit_message (j_common_ptr cinfo, int msg_level)
 {
  struct jpeg_error_mgr *err = cinfo->err;

@@ -153,7 +153,7 @@ emit_message(j_common_ptr cinfo, int msg_level)
 */

 METHODDEF(void)
-format_message(j_common_ptr cinfo, char *buffer)
+format_message (j_common_ptr cinfo, char *buffer)
 {
  struct jpeg_error_mgr *err = cinfo->err;
  int msg_code = err->msg_code;
@@ -208,7 +208,7 @@ format_message(j_common_ptr cinfo, char *buffer)
 */

 METHODDEF(void)
-reset_error_mgr(j_common_ptr cinfo)
+reset_error_mgr (j_common_ptr cinfo)
 {
  cinfo->err->num_warnings = 0;
  /* trace_level is not reset since it is an application-supplied parameter */
@@ -227,7 +227,7 @@ reset_error_mgr(j_common_ptr cinfo)
 */

 GLOBAL(struct jpeg_error_mgr *)
-jpeg_std_error(struct jpeg_error_mgr *err)
+jpeg_std_error (struct jpeg_error_mgr *err)
 {
  err->error_exit = error_exit;
  err->emit_message = emit_message;
@@ -241,7 +241,7 @@ jpeg_std_error(struct jpeg_error_mgr *err)

  /* Initialize message table pointers */
  err->jpeg_message_table = jpeg_std_message_table;
-  err->last_jpeg_message = (int)JMSG_LASTMSGCODE - 1;
+  err->last_jpeg_message = (int) JMSG_LASTMSGCODE - 1;

  err->addon_message_table = NULL;
  err->first_addon_message = 0; /* for safety */
@@ -5,7 +5,7 @@
 * Copyright (C) 1994-1997, Thomas G. Lane.
 * Modified 1997-2009 by Guido Vollbeding.
 * libjpeg-turbo Modifications:
- * Copyright (C) 2014, 2017, D. R. Commander.
+ * Copyright (C) 2014, D. R. Commander.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
 *
@@ -28,7 +28,7 @@
 #define JMAKE_ENUM_LIST
 #else
 /* Repeated inclusions of this file are no-ops unless JMESSAGE is defined */
-#define JMESSAGE(code, string)
+#define JMESSAGE(code,string)
 #endif /* JERROR_H */
 #endif /* JMESSAGE */

@@ -36,7 +36,7 @@

 typedef enum {

-#define JMESSAGE(code, string)  code,
+#define JMESSAGE(code,string)   code ,

 #endif /* JMAKE_ENUM_LIST */

@@ -44,7 +44,8 @@ JMESSAGE(JMSG_NOMESSAGE, "Bogus message code %d") /* Must be first entry! */

 /* For maintenance convenience, list is alphabetical by message code name */
 #if JPEG_LIB_VERSION < 70
-JMESSAGE(JERR_ARITH_NOTIMPL, "Sorry, arithmetic coding is not implemented")
+JMESSAGE(JERR_ARITH_NOTIMPL,
+         "Sorry, arithmetic coding is not implemented")
 #endif
 JMESSAGE(JERR_BAD_ALIGN_TYPE, "ALIGN_TYPE is wrong, please fix")
 JMESSAGE(JERR_BAD_ALLOC_CHUNK, "MAX_ALLOC_CHUNK is wrong, please fix")
@@ -153,7 +154,8 @@ JMESSAGE(JTRC_HUFFBITS, "        %3d %3d %3d %3d %3d %3d %3d %3d")
 JMESSAGE(JTRC_JFIF, "JFIF APP0 marker: version %d.%02d, density %dx%d  %d")
 JMESSAGE(JTRC_JFIF_BADTHUMBNAILSIZE,
         "Warning: thumbnail image size does not match data length %u")
-JMESSAGE(JTRC_JFIF_EXTENSION, "JFIF extension marker: type 0x%02x, length %u")
+JMESSAGE(JTRC_JFIF_EXTENSION,
+         "JFIF extension marker: type 0x%02x, length %u")
 JMESSAGE(JTRC_JFIF_THUMBNAIL, "    with %d x %d thumbnail image")
 JMESSAGE(JTRC_MISC_MARKER, "Miscellaneous marker 0x%02x, length %u")
 JMESSAGE(JTRC_PARMLESS_MARKER, "Unexpected marker 0x%02x")
@@ -206,11 +208,6 @@ JMESSAGE(JERR_NO_ARITH_TABLE, "Arithmetic table 0x%02x was not defined")
 JMESSAGE(JWRN_ARITH_BAD_CODE, "Corrupt JPEG data: bad arithmetic code")
 #endif
 #endif
-JMESSAGE(JWRN_BOGUS_ICC, "Corrupt JPEG data: bad ICC marker")
-#if JPEG_LIB_VERSION < 70
-JMESSAGE(JERR_BAD_DROP_SAMPLING,
-         "Component index %d: mismatching sampling ratio %d:%d, %d:%d, %c")
-#endif

 #ifdef JMAKE_ENUM_LIST

@@ -231,99 +228,90 @@ JMESSAGE(JERR_BAD_DROP_SAMPLING,
 /* The first parameter is either type of cinfo pointer */

 /* Fatal errors (print message and exit) */
-#define ERREXIT(cinfo, code) \
+#define ERREXIT(cinfo,code)  \
  ((cinfo)->err->msg_code = (code), \
-   (*(cinfo)->err->error_exit) ((j_common_ptr)(cinfo)))
-#define ERREXIT1(cinfo, code, p1) \
+   (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXIT1(cinfo,code,p1)  \
  ((cinfo)->err->msg_code = (code), \
   (cinfo)->err->msg_parm.i[0] = (p1), \
-   (*(cinfo)->err->error_exit) ((j_common_ptr)(cinfo)))
-#define ERREXIT2(cinfo, code, p1, p2) \
+   (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXIT2(cinfo,code,p1,p2)  \
  ((cinfo)->err->msg_code = (code), \
   (cinfo)->err->msg_parm.i[0] = (p1), \
   (cinfo)->err->msg_parm.i[1] = (p2), \
-   (*(cinfo)->err->error_exit) ((j_common_ptr)(cinfo)))
-#define ERREXIT3(cinfo, code, p1, p2, p3) \
+   (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXIT3(cinfo,code,p1,p2,p3)  \
  ((cinfo)->err->msg_code = (code), \
   (cinfo)->err->msg_parm.i[0] = (p1), \
   (cinfo)->err->msg_parm.i[1] = (p2), \
   (cinfo)->err->msg_parm.i[2] = (p3), \
-   (*(cinfo)->err->error_exit) ((j_common_ptr)(cinfo)))
-#define ERREXIT4(cinfo, code, p1, p2, p3, p4) \
+   (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXIT4(cinfo,code,p1,p2,p3,p4)  \
  ((cinfo)->err->msg_code = (code), \
   (cinfo)->err->msg_parm.i[0] = (p1), \
   (cinfo)->err->msg_parm.i[1] = (p2), \
   (cinfo)->err->msg_parm.i[2] = (p3), \
   (cinfo)->err->msg_parm.i[3] = (p4), \
-   (*(cinfo)->err->error_exit) ((j_common_ptr)(cinfo)))
-#define ERREXIT6(cinfo, code, p1, p2, p3, p4, p5, p6) \
-  ((cinfo)->err->msg_code = (code), \
-   (cinfo)->err->msg_parm.i[0] = (p1), \
-   (cinfo)->err->msg_parm.i[1] = (p2), \
-   (cinfo)->err->msg_parm.i[2] = (p3), \
-   (cinfo)->err->msg_parm.i[3] = (p4), \
-   (cinfo)->err->msg_parm.i[4] = (p5), \
-   (cinfo)->err->msg_parm.i[5] = (p6), \
-   (*(cinfo)->err->error_exit) ((j_common_ptr)(cinfo)))
-#define ERREXITS(cinfo, code, str) \
+   (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXITS(cinfo,code,str)  \
  ((cinfo)->err->msg_code = (code), \
   strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \
-   (*(cinfo)->err->error_exit) ((j_common_ptr)(cinfo)))
+   (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))

 #define MAKESTMT(stuff)         do { stuff } while (0)

 /* Nonfatal errors (we can keep going, but the data is probably corrupt) */
-#define WARNMS(cinfo, code) \
+#define WARNMS(cinfo,code)  \
  ((cinfo)->err->msg_code = (code), \
-   (*(cinfo)->err->emit_message) ((j_common_ptr)(cinfo), -1))
-#define WARNMS1(cinfo, code, p1) \
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1))
+#define WARNMS1(cinfo,code,p1)  \
  ((cinfo)->err->msg_code = (code), \
   (cinfo)->err->msg_parm.i[0] = (p1), \
-   (*(cinfo)->err->emit_message) ((j_common_ptr)(cinfo), -1))
-#define WARNMS2(cinfo, code, p1, p2) \
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1))
+#define WARNMS2(cinfo,code,p1,p2)  \
  ((cinfo)->err->msg_code = (code), \
   (cinfo)->err->msg_parm.i[0] = (p1), \
   (cinfo)->err->msg_parm.i[1] = (p2), \
-   (*(cinfo)->err->emit_message) ((j_common_ptr)(cinfo), -1))
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1))

 /* Informational/debugging messages */
-#define TRACEMS(cinfo, lvl, code) \
+#define TRACEMS(cinfo,lvl,code)  \
  ((cinfo)->err->msg_code = (code), \
-   (*(cinfo)->err->emit_message) ((j_common_ptr)(cinfo), (lvl)))
-#define TRACEMS1(cinfo, lvl, code, p1) \
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))
+#define TRACEMS1(cinfo,lvl,code,p1)  \
  ((cinfo)->err->msg_code = (code), \
   (cinfo)->err->msg_parm.i[0] = (p1), \
-   (*(cinfo)->err->emit_message) ((j_common_ptr)(cinfo), (lvl)))
-#define TRACEMS2(cinfo, lvl, code, p1, p2) \
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))
+#define TRACEMS2(cinfo,lvl,code,p1,p2)  \
  ((cinfo)->err->msg_code = (code), \
   (cinfo)->err->msg_parm.i[0] = (p1), \
   (cinfo)->err->msg_parm.i[1] = (p2), \
-   (*(cinfo)->err->emit_message) ((j_common_ptr)(cinfo), (lvl)))
-#define TRACEMS3(cinfo, lvl, code, p1, p2, p3) \
-  MAKESTMT(int *_mp = (cinfo)->err->msg_parm.i; \
-           _mp[0] = (p1);  _mp[1] = (p2);  _mp[2] = (p3); \
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))
+#define TRACEMS3(cinfo,lvl,code,p1,p2,p3)  \
+  MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \
+           _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); \
           (cinfo)->err->msg_code = (code); \
-           (*(cinfo)->err->emit_message) ((j_common_ptr)(cinfo), (lvl)); )
-#define TRACEMS4(cinfo, lvl, code, p1, p2, p3, p4) \
-  MAKESTMT(int *_mp = (cinfo)->err->msg_parm.i; \
-           _mp[0] = (p1);  _mp[1] = (p2);  _mp[2] = (p3);  _mp[3] = (p4); \
+           (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); )
+#define TRACEMS4(cinfo,lvl,code,p1,p2,p3,p4)  \
+  MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \
+           _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \
           (cinfo)->err->msg_code = (code); \
-           (*(cinfo)->err->emit_message) ((j_common_ptr)(cinfo), (lvl)); )
-#define TRACEMS5(cinfo, lvl, code, p1, p2, p3, p4, p5) \
-  MAKESTMT(int *_mp = (cinfo)->err->msg_parm.i; \
-           _mp[0] = (p1);  _mp[1] = (p2);  _mp[2] = (p3);  _mp[3] = (p4); \
+           (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); )
+#define TRACEMS5(cinfo,lvl,code,p1,p2,p3,p4,p5)  \
+  MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \
+           _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \
           _mp[4] = (p5); \
           (cinfo)->err->msg_code = (code); \
-           (*(cinfo)->err->emit_message) ((j_common_ptr)(cinfo), (lvl)); )
-#define TRACEMS8(cinfo, lvl, code, p1, p2, p3, p4, p5, p6, p7, p8) \
-  MAKESTMT(int *_mp = (cinfo)->err->msg_parm.i; \
-           _mp[0] = (p1);  _mp[1] = (p2);  _mp[2] = (p3);  _mp[3] = (p4); \
-           _mp[4] = (p5);  _mp[5] = (p6);  _mp[6] = (p7);  _mp[7] = (p8); \
+           (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); )
+#define TRACEMS8(cinfo,lvl,code,p1,p2,p3,p4,p5,p6,p7,p8)  \
+  MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \
+           _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \
+           _mp[4] = (p5); _mp[5] = (p6); _mp[6] = (p7); _mp[7] = (p8); \
           (cinfo)->err->msg_code = (code); \
-           (*(cinfo)->err->emit_message) ((j_common_ptr)(cinfo), (lvl)); )
-#define TRACEMSS(cinfo, lvl, code, str) \
+           (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); )
+#define TRACEMSS(cinfo,lvl,code,str)  \
  ((cinfo)->err->msg_code = (code), \
   strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \
-   (*(cinfo)->err->emit_message) ((j_common_ptr)(cinfo), (lvl)))
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))

 #endif /* JERROR_H */
@@ -57,7 +57,7 @@
 */

 GLOBAL(void)
-jpeg_fdct_float(FAST_FLOAT *data)
+jpeg_fdct_float (FAST_FLOAT *data)
 {
  FAST_FLOAT tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
  FAST_FLOAT tmp10, tmp11, tmp12, tmp13;
@@ -68,7 +68,7 @@ jpeg_fdct_float(FAST_FLOAT *data)
  /* Pass 1: process rows. */

  dataptr = data;
-  for (ctr = DCTSIZE - 1; ctr >= 0; ctr--) {
+  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
    tmp0 = dataptr[0] + dataptr[7];
    tmp7 = dataptr[0] - dataptr[7];
    tmp1 = dataptr[1] + dataptr[6];
@@ -88,7 +88,7 @@ jpeg_fdct_float(FAST_FLOAT *data)
    dataptr[0] = tmp10 + tmp11; /* phase 3 */
    dataptr[4] = tmp10 - tmp11;

-    z1 = (tmp12 + tmp13) * ((FAST_FLOAT)0.707106781); /* c4 */
+    z1 = (tmp12 + tmp13) * ((FAST_FLOAT) 0.707106781); /* c4 */
    dataptr[2] = tmp13 + z1;    /* phase 5 */
    dataptr[6] = tmp13 - z1;

@@ -99,10 +99,10 @@ jpeg_fdct_float(FAST_FLOAT *data)
    tmp12 = tmp6 + tmp7;

    /* The rotator is modified from fig 4-8 to avoid extra negations. */
-    z5 = (tmp10 - tmp12) * ((FAST_FLOAT)0.382683433); /* c6 */
-    z2 = ((FAST_FLOAT)0.541196100) * tmp10 + z5; /* c2-c6 */
-    z4 = ((FAST_FLOAT)1.306562965) * tmp12 + z5; /* c2+c6 */
-    z3 = tmp11 * ((FAST_FLOAT)0.707106781); /* c4 */
+    z5 = (tmp10 - tmp12) * ((FAST_FLOAT) 0.382683433); /* c6 */
+    z2 = ((FAST_FLOAT) 0.541196100) * tmp10 + z5; /* c2-c6 */
+    z4 = ((FAST_FLOAT) 1.306562965) * tmp12 + z5; /* c2+c6 */
+    z3 = tmp11 * ((FAST_FLOAT) 0.707106781); /* c4 */

    z11 = tmp7 + z3;            /* phase 5 */
    z13 = tmp7 - z3;
@@ -118,15 +118,15 @@ jpeg_fdct_float(FAST_FLOAT *data)
  /* Pass 2: process columns. */

  dataptr = data;
-  for (ctr = DCTSIZE - 1; ctr >= 0; ctr--) {
-    tmp0 = dataptr[DCTSIZE * 0] + dataptr[DCTSIZE * 7];
-    tmp7 = dataptr[DCTSIZE * 0] - dataptr[DCTSIZE * 7];
-    tmp1 = dataptr[DCTSIZE * 1] + dataptr[DCTSIZE * 6];
-    tmp6 = dataptr[DCTSIZE * 1] - dataptr[DCTSIZE * 6];
-    tmp2 = dataptr[DCTSIZE * 2] + dataptr[DCTSIZE * 5];
-    tmp5 = dataptr[DCTSIZE * 2] - dataptr[DCTSIZE * 5];
-    tmp3 = dataptr[DCTSIZE * 3] + dataptr[DCTSIZE * 4];
-    tmp4 = dataptr[DCTSIZE * 3] - dataptr[DCTSIZE * 4];
+  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
+    tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7];
+    tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7];
+    tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6];
+    tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6];
+    tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5];
+    tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5];
+    tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4];
+    tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4];

    /* Even part */

@@ -135,12 +135,12 @@ jpeg_fdct_float(FAST_FLOAT *data)
    tmp11 = tmp1 + tmp2;
    tmp12 = tmp1 - tmp2;

-    dataptr[DCTSIZE * 0] = tmp10 + tmp11; /* phase 3 */
-    dataptr[DCTSIZE * 4] = tmp10 - tmp11;
+    dataptr[DCTSIZE*0] = tmp10 + tmp11; /* phase 3 */
+    dataptr[DCTSIZE*4] = tmp10 - tmp11;

-    z1 = (tmp12 + tmp13) * ((FAST_FLOAT)0.707106781); /* c4 */
-    dataptr[DCTSIZE * 2] = tmp13 + z1; /* phase 5 */
-    dataptr[DCTSIZE * 6] = tmp13 - z1;
+    z1 = (tmp12 + tmp13) * ((FAST_FLOAT) 0.707106781); /* c4 */
+    dataptr[DCTSIZE*2] = tmp13 + z1; /* phase 5 */
+    dataptr[DCTSIZE*6] = tmp13 - z1;

    /* Odd part */

@@ -149,18 +149,18 @@ jpeg_fdct_float(FAST_FLOAT *data)
    tmp12 = tmp6 + tmp7;

    /* The rotator is modified from fig 4-8 to avoid extra negations. */
-    z5 = (tmp10 - tmp12) * ((FAST_FLOAT)0.382683433); /* c6 */
-    z2 = ((FAST_FLOAT)0.541196100) * tmp10 + z5; /* c2-c6 */
-    z4 = ((FAST_FLOAT)1.306562965) * tmp12 + z5; /* c2+c6 */
-    z3 = tmp11 * ((FAST_FLOAT)0.707106781); /* c4 */
+    z5 = (tmp10 - tmp12) * ((FAST_FLOAT) 0.382683433); /* c6 */
+    z2 = ((FAST_FLOAT) 0.541196100) * tmp10 + z5; /* c2-c6 */
+    z4 = ((FAST_FLOAT) 1.306562965) * tmp12 + z5; /* c2+c6 */
+    z3 = tmp11 * ((FAST_FLOAT) 0.707106781); /* c4 */

    z11 = tmp7 + z3;            /* phase 5 */
    z13 = tmp7 - z3;

-    dataptr[DCTSIZE * 5] = z13 + z2; /* phase 6 */
-    dataptr[DCTSIZE * 3] = z13 - z2;
-    dataptr[DCTSIZE * 1] = z11 + z4;
-    dataptr[DCTSIZE * 7] = z11 - z4;
+    dataptr[DCTSIZE*5] = z13 + z2; /* phase 6 */
+    dataptr[DCTSIZE*3] = z13 - z2;
+    dataptr[DCTSIZE*1] = z11 + z4;
+    dataptr[DCTSIZE*7] = z11 - z4;

    dataptr++;                  /* advance pointer to next column */
  }
@@ -79,10 +79,10 @@
 */

 #if CONST_BITS == 8
-#define FIX_0_382683433  ((JLONG)98)            /* FIX(0.382683433) */
-#define FIX_0_541196100  ((JLONG)139)           /* FIX(0.541196100) */
-#define FIX_0_707106781  ((JLONG)181)           /* FIX(0.707106781) */
-#define FIX_1_306562965  ((JLONG)334)           /* FIX(1.306562965) */
+#define FIX_0_382683433  ((JLONG)   98)         /* FIX(0.382683433) */
+#define FIX_0_541196100  ((JLONG)  139)         /* FIX(0.541196100) */
+#define FIX_0_707106781  ((JLONG)  181)         /* FIX(0.707106781) */
+#define FIX_1_306562965  ((JLONG)  334)         /* FIX(1.306562965) */
 #else
 #define FIX_0_382683433  FIX(0.382683433)
 #define FIX_0_541196100  FIX(0.541196100)
@@ -98,7 +98,7 @@

 #ifndef USE_ACCURATE_ROUNDING
 #undef DESCALE
-#define DESCALE(x, n)  RIGHT_SHIFT(x, n)
+#define DESCALE(x,n)  RIGHT_SHIFT(x, n)
 #endif


@@ -106,7 +106,7 @@
 * descale to yield a DCTELEM result.
 */

-#define MULTIPLY(var, const)  ((DCTELEM)DESCALE((var) * (const), CONST_BITS))
+#define MULTIPLY(var,const)  ((DCTELEM) DESCALE((var) * (const), CONST_BITS))


 /*
@@ -114,7 +114,7 @@
 */

 GLOBAL(void)
-jpeg_fdct_ifast(DCTELEM *data)
+jpeg_fdct_ifast (DCTELEM *data)
 {
  DCTELEM tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
  DCTELEM tmp10, tmp11, tmp12, tmp13;
@@ -126,7 +126,7 @@ jpeg_fdct_ifast(DCTELEM *data)
  /* Pass 1: process rows. */

  dataptr = data;
-  for (ctr = DCTSIZE - 1; ctr >= 0; ctr--) {
+  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
    tmp0 = dataptr[0] + dataptr[7];
    tmp7 = dataptr[0] - dataptr[7];
    tmp1 = dataptr[1] + dataptr[6];
@@ -176,15 +176,15 @@ jpeg_fdct_ifast(DCTELEM *data)
  /* Pass 2: process columns. */

  dataptr = data;
-  for (ctr = DCTSIZE - 1; ctr >= 0; ctr--) {
-    tmp0 = dataptr[DCTSIZE * 0] + dataptr[DCTSIZE * 7];
-    tmp7 = dataptr[DCTSIZE * 0] - dataptr[DCTSIZE * 7];
-    tmp1 = dataptr[DCTSIZE * 1] + dataptr[DCTSIZE * 6];
-    tmp6 = dataptr[DCTSIZE * 1] - dataptr[DCTSIZE * 6];
-    tmp2 = dataptr[DCTSIZE * 2] + dataptr[DCTSIZE * 5];
-    tmp5 = dataptr[DCTSIZE * 2] - dataptr[DCTSIZE * 5];
-    tmp3 = dataptr[DCTSIZE * 3] + dataptr[DCTSIZE * 4];
-    tmp4 = dataptr[DCTSIZE * 3] - dataptr[DCTSIZE * 4];
+  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
+    tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7];
+    tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7];
+    tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6];
+    tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6];
+    tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5];
+    tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5];
+    tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4];
+    tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4];

    /* Even part */

@@ -193,12 +193,12 @@ jpeg_fdct_ifast(DCTELEM *data)
    tmp11 = tmp1 + tmp2;
    tmp12 = tmp1 - tmp2;

-    dataptr[DCTSIZE * 0] = tmp10 + tmp11; /* phase 3 */
-    dataptr[DCTSIZE * 4] = tmp10 - tmp11;
+    dataptr[DCTSIZE*0] = tmp10 + tmp11; /* phase 3 */
+    dataptr[DCTSIZE*4] = tmp10 - tmp11;

    z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */
-    dataptr[DCTSIZE * 2] = tmp13 + z1; /* phase 5 */
-    dataptr[DCTSIZE * 6] = tmp13 - z1;
+    dataptr[DCTSIZE*2] = tmp13 + z1; /* phase 5 */
+    dataptr[DCTSIZE*6] = tmp13 - z1;

    /* Odd part */

@@ -215,10 +215,10 @@ jpeg_fdct_ifast(DCTELEM *data)
    z11 = tmp7 + z3;            /* phase 5 */
    z13 = tmp7 - z3;

-    dataptr[DCTSIZE * 5] = z13 + z2; /* phase 6 */
-    dataptr[DCTSIZE * 3] = z13 - z2;
-    dataptr[DCTSIZE * 1] = z11 + z4;
-    dataptr[DCTSIZE * 7] = z11 - z4;
+    dataptr[DCTSIZE*5] = z13 + z2; /* phase 6 */
+    dataptr[DCTSIZE*3] = z13 - z2;
+    dataptr[DCTSIZE*1] = z11 + z4;
+    dataptr[DCTSIZE*7] = z11 - z4;

    dataptr++;                  /* advance pointer to next column */
  }
@@ -1,14 +1,14 @@
 /*
 * jfdctint.c
 *
- * This file was part of the Independent JPEG Group's software:
+ * This file was part of the Independent JPEG Group's software.
 * Copyright (C) 1991-1996, Thomas G. Lane.
 * libjpeg-turbo Modifications:
- * Copyright (C) 2015, 2020, D. R. Commander.
+ * Copyright (C) 2015, D. R. Commander.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
 *
- * This file contains a slower but more accurate integer implementation of the
+ * This file contains a slow-but-accurate integer implementation of the
 * forward DCT (Discrete Cosine Transform).
 *
 * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT
@@ -93,18 +93,18 @@
 */

 #if CONST_BITS == 13
-#define FIX_0_298631336  ((JLONG)2446)          /* FIX(0.298631336) */
-#define FIX_0_390180644  ((JLONG)3196)          /* FIX(0.390180644) */
-#define FIX_0_541196100  ((JLONG)4433)          /* FIX(0.541196100) */
-#define FIX_0_765366865  ((JLONG)6270)          /* FIX(0.765366865) */
-#define FIX_0_899976223  ((JLONG)7373)          /* FIX(0.899976223) */
-#define FIX_1_175875602  ((JLONG)9633)          /* FIX(1.175875602) */
-#define FIX_1_501321110  ((JLONG)12299)         /* FIX(1.501321110) */
-#define FIX_1_847759065  ((JLONG)15137)         /* FIX(1.847759065) */
-#define FIX_1_961570560  ((JLONG)16069)         /* FIX(1.961570560) */
-#define FIX_2_053119869  ((JLONG)16819)         /* FIX(2.053119869) */
-#define FIX_2_562915447  ((JLONG)20995)         /* FIX(2.562915447) */
-#define FIX_3_072711026  ((JLONG)25172)         /* FIX(3.072711026) */
+#define FIX_0_298631336  ((JLONG)  2446)        /* FIX(0.298631336) */
+#define FIX_0_390180644  ((JLONG)  3196)        /* FIX(0.390180644) */
+#define FIX_0_541196100  ((JLONG)  4433)        /* FIX(0.541196100) */
+#define FIX_0_765366865  ((JLONG)  6270)        /* FIX(0.765366865) */
+#define FIX_0_899976223  ((JLONG)  7373)        /* FIX(0.899976223) */
+#define FIX_1_175875602  ((JLONG)  9633)        /* FIX(1.175875602) */
+#define FIX_1_501321110  ((JLONG)  12299)       /* FIX(1.501321110) */
+#define FIX_1_847759065  ((JLONG)  15137)       /* FIX(1.847759065) */
+#define FIX_1_961570560  ((JLONG)  16069)       /* FIX(1.961570560) */
+#define FIX_2_053119869  ((JLONG)  16819)       /* FIX(2.053119869) */
+#define FIX_2_562915447  ((JLONG)  20995)       /* FIX(2.562915447) */
+#define FIX_3_072711026  ((JLONG)  25172)       /* FIX(3.072711026) */
 #else
 #define FIX_0_298631336  FIX(0.298631336)
 #define FIX_0_390180644  FIX(0.390180644)
@@ -129,9 +129,9 @@
 */

 #if BITS_IN_JSAMPLE == 8
-#define MULTIPLY(var, const)  MULTIPLY16C16(var, const)
+#define MULTIPLY(var,const)  MULTIPLY16C16(var,const)
 #else
-#define MULTIPLY(var, const)  ((var) * (const))
+#define MULTIPLY(var,const)  ((var) * (const))
 #endif


@@ -140,7 +140,7 @@
 */

 GLOBAL(void)
-jpeg_fdct_islow(DCTELEM *data)
+jpeg_fdct_islow (DCTELEM *data)
 {
  JLONG tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
  JLONG tmp10, tmp11, tmp12, tmp13;
@@ -154,7 +154,7 @@ jpeg_fdct_islow(DCTELEM *data)
  /* furthermore, we scale the results by 2**PASS1_BITS. */

  dataptr = data;
-  for (ctr = DCTSIZE - 1; ctr >= 0; ctr--) {
+  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
    tmp0 = dataptr[0] + dataptr[7];
    tmp7 = dataptr[0] - dataptr[7];
    tmp1 = dataptr[1] + dataptr[6];
@@ -173,14 +173,14 @@ jpeg_fdct_islow(DCTELEM *data)
    tmp11 = tmp1 + tmp2;
    tmp12 = tmp1 - tmp2;

-    dataptr[0] = (DCTELEM)LEFT_SHIFT(tmp10 + tmp11, PASS1_BITS);
-    dataptr[4] = (DCTELEM)LEFT_SHIFT(tmp10 - tmp11, PASS1_BITS);
+    dataptr[0] = (DCTELEM) LEFT_SHIFT(tmp10 + tmp11, PASS1_BITS);
+    dataptr[4] = (DCTELEM) LEFT_SHIFT(tmp10 - tmp11, PASS1_BITS);

    z1 = MULTIPLY(tmp12 + tmp13, FIX_0_541196100);
-    dataptr[2] = (DCTELEM)DESCALE(z1 + MULTIPLY(tmp13, FIX_0_765366865),
-                                  CONST_BITS - PASS1_BITS);
-    dataptr[6] = (DCTELEM)DESCALE(z1 + MULTIPLY(tmp12, -FIX_1_847759065),
-                                  CONST_BITS - PASS1_BITS);
+    dataptr[2] = (DCTELEM) DESCALE(z1 + MULTIPLY(tmp13, FIX_0_765366865),
+                                   CONST_BITS-PASS1_BITS);
+    dataptr[6] = (DCTELEM) DESCALE(z1 + MULTIPLY(tmp12, - FIX_1_847759065),
+                                   CONST_BITS-PASS1_BITS);

    /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
     * cK represents cos(K*pi/16).
@@ -197,18 +197,18 @@ jpeg_fdct_islow(DCTELEM *data)
    tmp5 = MULTIPLY(tmp5, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */
    tmp6 = MULTIPLY(tmp6, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */
    tmp7 = MULTIPLY(tmp7, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */
-    z1 = MULTIPLY(z1, -FIX_0_899976223); /* sqrt(2) * ( c7-c3) */
-    z2 = MULTIPLY(z2, -FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
-    z3 = MULTIPLY(z3, -FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
-    z4 = MULTIPLY(z4, -FIX_0_390180644); /* sqrt(2) * ( c5-c3) */
+    z1 = MULTIPLY(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */
+    z2 = MULTIPLY(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
+    z3 = MULTIPLY(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
+    z4 = MULTIPLY(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */

    z3 += z5;
    z4 += z5;

-    dataptr[7] = (DCTELEM)DESCALE(tmp4 + z1 + z3, CONST_BITS - PASS1_BITS);
-    dataptr[5] = (DCTELEM)DESCALE(tmp5 + z2 + z4, CONST_BITS - PASS1_BITS);
-    dataptr[3] = (DCTELEM)DESCALE(tmp6 + z2 + z3, CONST_BITS - PASS1_BITS);
-    dataptr[1] = (DCTELEM)DESCALE(tmp7 + z1 + z4, CONST_BITS - PASS1_BITS);
+    dataptr[7] = (DCTELEM) DESCALE(tmp4 + z1 + z3, CONST_BITS-PASS1_BITS);
+    dataptr[5] = (DCTELEM) DESCALE(tmp5 + z2 + z4, CONST_BITS-PASS1_BITS);
+    dataptr[3] = (DCTELEM) DESCALE(tmp6 + z2 + z3, CONST_BITS-PASS1_BITS);
+    dataptr[1] = (DCTELEM) DESCALE(tmp7 + z1 + z4, CONST_BITS-PASS1_BITS);

    dataptr += DCTSIZE;         /* advance pointer to next row */
  }
@@ -219,15 +219,15 @@ jpeg_fdct_islow(DCTELEM *data)
   */

  dataptr = data;
-  for (ctr = DCTSIZE - 1; ctr >= 0; ctr--) {
-    tmp0 = dataptr[DCTSIZE * 0] + dataptr[DCTSIZE * 7];
-    tmp7 = dataptr[DCTSIZE * 0] - dataptr[DCTSIZE * 7];
-    tmp1 = dataptr[DCTSIZE * 1] + dataptr[DCTSIZE * 6];
-    tmp6 = dataptr[DCTSIZE * 1] - dataptr[DCTSIZE * 6];
-    tmp2 = dataptr[DCTSIZE * 2] + dataptr[DCTSIZE * 5];
-    tmp5 = dataptr[DCTSIZE * 2] - dataptr[DCTSIZE * 5];
-    tmp3 = dataptr[DCTSIZE * 3] + dataptr[DCTSIZE * 4];
-    tmp4 = dataptr[DCTSIZE * 3] - dataptr[DCTSIZE * 4];
+  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
+    tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7];
+    tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7];
+    tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6];
+    tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6];
+    tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5];
+    tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5];
+    tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4];
+    tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4];

    /* Even part per LL&M figure 1 --- note that published figure is faulty;
     * rotator "sqrt(2)*c1" should be "sqrt(2)*c6".
@@ -238,16 +238,14 @@ jpeg_fdct_islow(DCTELEM *data)
    tmp11 = tmp1 + tmp2;
    tmp12 = tmp1 - tmp2;

-    dataptr[DCTSIZE * 0] = (DCTELEM)DESCALE(tmp10 + tmp11, PASS1_BITS);
-    dataptr[DCTSIZE * 4] = (DCTELEM)DESCALE(tmp10 - tmp11, PASS1_BITS);
+    dataptr[DCTSIZE*0] = (DCTELEM) DESCALE(tmp10 + tmp11, PASS1_BITS);
+    dataptr[DCTSIZE*4] = (DCTELEM) DESCALE(tmp10 - tmp11, PASS1_BITS);

    z1 = MULTIPLY(tmp12 + tmp13, FIX_0_541196100);
-    dataptr[DCTSIZE * 2] =
-      (DCTELEM)DESCALE(z1 + MULTIPLY(tmp13, FIX_0_765366865),
-                       CONST_BITS + PASS1_BITS);
-    dataptr[DCTSIZE * 6] =
-      (DCTELEM)DESCALE(z1 + MULTIPLY(tmp12, -FIX_1_847759065),
-                       CONST_BITS + PASS1_BITS);
+    dataptr[DCTSIZE*2] = (DCTELEM) DESCALE(z1 + MULTIPLY(tmp13, FIX_0_765366865),
+                                           CONST_BITS+PASS1_BITS);
+    dataptr[DCTSIZE*6] = (DCTELEM) DESCALE(z1 + MULTIPLY(tmp12, - FIX_1_847759065),
+                                           CONST_BITS+PASS1_BITS);

    /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
     * cK represents cos(K*pi/16).
@@ -264,22 +262,22 @@ jpeg_fdct_islow(DCTELEM *data)
    tmp5 = MULTIPLY(tmp5, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */
    tmp6 = MULTIPLY(tmp6, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */
    tmp7 = MULTIPLY(tmp7, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */
-    z1 = MULTIPLY(z1, -FIX_0_899976223); /* sqrt(2) * ( c7-c3) */
-    z2 = MULTIPLY(z2, -FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
-    z3 = MULTIPLY(z3, -FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
-    z4 = MULTIPLY(z4, -FIX_0_390180644); /* sqrt(2) * ( c5-c3) */
+    z1 = MULTIPLY(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */
+    z2 = MULTIPLY(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
+    z3 = MULTIPLY(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
+    z4 = MULTIPLY(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */

    z3 += z5;
    z4 += z5;

-    dataptr[DCTSIZE * 7] = (DCTELEM)DESCALE(tmp4 + z1 + z3,
-                                            CONST_BITS + PASS1_BITS);
-    dataptr[DCTSIZE * 5] = (DCTELEM)DESCALE(tmp5 + z2 + z4,
-                                            CONST_BITS + PASS1_BITS);
-    dataptr[DCTSIZE * 3] = (DCTELEM)DESCALE(tmp6 + z2 + z3,
-                                            CONST_BITS + PASS1_BITS);
-    dataptr[DCTSIZE * 1] = (DCTELEM)DESCALE(tmp7 + z1 + z4,
-                                            CONST_BITS + PASS1_BITS);
+    dataptr[DCTSIZE*7] = (DCTELEM) DESCALE(tmp4 + z1 + z3,
+                                           CONST_BITS+PASS1_BITS);
+    dataptr[DCTSIZE*5] = (DCTELEM) DESCALE(tmp5 + z2 + z4,
+                                           CONST_BITS+PASS1_BITS);
+    dataptr[DCTSIZE*3] = (DCTELEM) DESCALE(tmp6 + z2 + z3,
+                                           CONST_BITS+PASS1_BITS);
+    dataptr[DCTSIZE*1] = (DCTELEM) DESCALE(tmp7 + z1 + z4,
+                                           CONST_BITS+PASS1_BITS);

    dataptr++;                  /* advance pointer to next column */
  }
@@ -61,7 +61,7 @@
 * entry; produce a float result.
 */

-#define DEQUANTIZE(coef, quantval)  (((FAST_FLOAT)(coef)) * (quantval))
+#define DEQUANTIZE(coef,quantval)  (((FAST_FLOAT) (coef)) * (quantval))


 /*
@@ -69,9 +69,9 @@
 */

 GLOBAL(void)
-jpeg_idct_float(j_decompress_ptr cinfo, jpeg_component_info *compptr,
-                JCOEFPTR coef_block, JSAMPARRAY output_buf,
-                JDIMENSION output_col)
+jpeg_idct_float (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block,
+                 JSAMPARRAY output_buf, JDIMENSION output_col)
 {
  FAST_FLOAT tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
  FAST_FLOAT tmp10, tmp11, tmp12, tmp13;
@@ -83,12 +83,12 @@ jpeg_idct_float(j_decompress_ptr cinfo, jpeg_component_info *compptr,
  JSAMPLE *range_limit = cinfo->sample_range_limit;
  int ctr;
  FAST_FLOAT workspace[DCTSIZE2]; /* buffers data between passes */
-#define _0_125  ((FLOAT_MULT_TYPE)0.125)
+  #define _0_125 ((FLOAT_MULT_TYPE)0.125)

  /* Pass 1: process columns from input, store into work array. */

  inptr = coef_block;
-  quantptr = (FLOAT_MULT_TYPE *)compptr->dct_table;
+  quantptr = (FLOAT_MULT_TYPE *) compptr->dct_table;
  wsptr = workspace;
  for (ctr = DCTSIZE; ctr > 0; ctr--) {
    /* Due to quantization, we will usually find that many of the input
@@ -100,22 +100,22 @@ jpeg_idct_float(j_decompress_ptr cinfo, jpeg_component_info *compptr,
     * column DCT calculations can be simplified this way.
     */

-    if (inptr[DCTSIZE * 1] == 0 && inptr[DCTSIZE * 2] == 0 &&
-        inptr[DCTSIZE * 3] == 0 && inptr[DCTSIZE * 4] == 0 &&
-        inptr[DCTSIZE * 5] == 0 && inptr[DCTSIZE * 6] == 0 &&
-        inptr[DCTSIZE * 7] == 0) {
+    if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 &&
+        inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*4] == 0 &&
+        inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*6] == 0 &&
+        inptr[DCTSIZE*7] == 0) {
      /* AC terms all zero */
-      FAST_FLOAT dcval = DEQUANTIZE(inptr[DCTSIZE * 0],
-                                    quantptr[DCTSIZE * 0] * _0_125);
+      FAST_FLOAT dcval = DEQUANTIZE(inptr[DCTSIZE*0],
+                                    quantptr[DCTSIZE*0] * _0_125);

-      wsptr[DCTSIZE * 0] = dcval;
-      wsptr[DCTSIZE * 1] = dcval;
-      wsptr[DCTSIZE * 2] = dcval;
-      wsptr[DCTSIZE * 3] = dcval;
-      wsptr[DCTSIZE * 4] = dcval;
-      wsptr[DCTSIZE * 5] = dcval;
-      wsptr[DCTSIZE * 6] = dcval;
-      wsptr[DCTSIZE * 7] = dcval;
+      wsptr[DCTSIZE*0] = dcval;
+      wsptr[DCTSIZE*1] = dcval;
+      wsptr[DCTSIZE*2] = dcval;
+      wsptr[DCTSIZE*3] = dcval;
+      wsptr[DCTSIZE*4] = dcval;
+      wsptr[DCTSIZE*5] = dcval;
+      wsptr[DCTSIZE*6] = dcval;
+      wsptr[DCTSIZE*7] = dcval;

      inptr++;                  /* advance pointers to next column */
      quantptr++;
@@ -125,16 +125,16 @@ jpeg_idct_float(j_decompress_ptr cinfo, jpeg_component_info *compptr,

    /* Even part */

-    tmp0 = DEQUANTIZE(inptr[DCTSIZE * 0], quantptr[DCTSIZE * 0] * _0_125);
-    tmp1 = DEQUANTIZE(inptr[DCTSIZE * 2], quantptr[DCTSIZE * 2] * _0_125);
-    tmp2 = DEQUANTIZE(inptr[DCTSIZE * 4], quantptr[DCTSIZE * 4] * _0_125);
-    tmp3 = DEQUANTIZE(inptr[DCTSIZE * 6], quantptr[DCTSIZE * 6] * _0_125);
+    tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0] * _0_125);
+    tmp1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2] * _0_125);
+    tmp2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4] * _0_125);
+    tmp3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6] * _0_125);

    tmp10 = tmp0 + tmp2;        /* phase 3 */
    tmp11 = tmp0 - tmp2;

    tmp13 = tmp1 + tmp3;        /* phases 5-3 */
-    tmp12 = (tmp1 - tmp3) * ((FAST_FLOAT)1.414213562) - tmp13; /* 2*c4 */
+    tmp12 = (tmp1 - tmp3) * ((FAST_FLOAT) 1.414213562) - tmp13; /* 2*c4 */

    tmp0 = tmp10 + tmp13;       /* phase 2 */
    tmp3 = tmp10 - tmp13;
@@ -143,10 +143,10 @@ jpeg_idct_float(j_decompress_ptr cinfo, jpeg_component_info *compptr,

    /* Odd part */

-    tmp4 = DEQUANTIZE(inptr[DCTSIZE * 1], quantptr[DCTSIZE * 1] * _0_125);
-    tmp5 = DEQUANTIZE(inptr[DCTSIZE * 3], quantptr[DCTSIZE * 3] * _0_125);
-    tmp6 = DEQUANTIZE(inptr[DCTSIZE * 5], quantptr[DCTSIZE * 5] * _0_125);
-    tmp7 = DEQUANTIZE(inptr[DCTSIZE * 7], quantptr[DCTSIZE * 7] * _0_125);
+    tmp4 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1] * _0_125);
+    tmp5 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3] * _0_125);
+    tmp6 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5] * _0_125);
+    tmp7 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7] * _0_125);

    z13 = tmp6 + tmp5;          /* phase 6 */
    z10 = tmp6 - tmp5;
@@ -154,24 +154,24 @@ jpeg_idct_float(j_decompress_ptr cinfo, jpeg_component_info *compptr,
    z12 = tmp4 - tmp7;

    tmp7 = z11 + z13;           /* phase 5 */
-    tmp11 = (z11 - z13) * ((FAST_FLOAT)1.414213562); /* 2*c4 */
+    tmp11 = (z11 - z13) * ((FAST_FLOAT) 1.414213562); /* 2*c4 */

-    z5 = (z10 + z12) * ((FAST_FLOAT)1.847759065); /* 2*c2 */
-    tmp10 = z5 - z12 * ((FAST_FLOAT)1.082392200); /* 2*(c2-c6) */
-    tmp12 = z5 - z10 * ((FAST_FLOAT)2.613125930); /* 2*(c2+c6) */
+    z5 = (z10 + z12) * ((FAST_FLOAT) 1.847759065); /* 2*c2 */
+    tmp10 = z5 - z12 * ((FAST_FLOAT) 1.082392200); /* 2*(c2-c6) */
+    tmp12 = z5 - z10 * ((FAST_FLOAT) 2.613125930); /* 2*(c2+c6) */

    tmp6 = tmp12 - tmp7;        /* phase 2 */
    tmp5 = tmp11 - tmp6;
    tmp4 = tmp10 - tmp5;

-    wsptr[DCTSIZE * 0] = tmp0 + tmp7;
-    wsptr[DCTSIZE * 7] = tmp0 - tmp7;
-    wsptr[DCTSIZE * 1] = tmp1 + tmp6;
-    wsptr[DCTSIZE * 6] = tmp1 - tmp6;
-    wsptr[DCTSIZE * 2] = tmp2 + tmp5;
-    wsptr[DCTSIZE * 5] = tmp2 - tmp5;
-    wsptr[DCTSIZE * 3] = tmp3 + tmp4;
-    wsptr[DCTSIZE * 4] = tmp3 - tmp4;
+    wsptr[DCTSIZE*0] = tmp0 + tmp7;
+    wsptr[DCTSIZE*7] = tmp0 - tmp7;
+    wsptr[DCTSIZE*1] = tmp1 + tmp6;
+    wsptr[DCTSIZE*6] = tmp1 - tmp6;
+    wsptr[DCTSIZE*2] = tmp2 + tmp5;
+    wsptr[DCTSIZE*5] = tmp2 - tmp5;
+    wsptr[DCTSIZE*3] = tmp3 + tmp4;
+    wsptr[DCTSIZE*4] = tmp3 - tmp4;

    inptr++;                    /* advance pointers to next column */
    quantptr++;
@@ -192,12 +192,12 @@ jpeg_idct_float(j_decompress_ptr cinfo, jpeg_component_info *compptr,
    /* Even part */

    /* Apply signed->unsigned and prepare float->int conversion */
-    z5 = wsptr[0] + ((FAST_FLOAT)CENTERJSAMPLE + (FAST_FLOAT)0.5);
+    z5 = wsptr[0] + ((FAST_FLOAT) CENTERJSAMPLE + (FAST_FLOAT) 0.5);
    tmp10 = z5 + wsptr[4];
    tmp11 = z5 - wsptr[4];

    tmp13 = wsptr[2] + wsptr[6];
-    tmp12 = (wsptr[2] - wsptr[6]) * ((FAST_FLOAT)1.414213562) - tmp13;
+    tmp12 = (wsptr[2] - wsptr[6]) * ((FAST_FLOAT) 1.414213562) - tmp13;

    tmp0 = tmp10 + tmp13;
    tmp3 = tmp10 - tmp13;
@@ -212,11 +212,11 @@ jpeg_idct_float(j_decompress_ptr cinfo, jpeg_component_info *compptr,
    z12 = wsptr[1] - wsptr[7];

    tmp7 = z11 + z13;
-    tmp11 = (z11 - z13) * ((FAST_FLOAT)1.414213562);
+    tmp11 = (z11 - z13) * ((FAST_FLOAT) 1.414213562);

-    z5 = (z10 + z12) * ((FAST_FLOAT)1.847759065); /* 2*c2 */
-    tmp10 = z5 - z12 * ((FAST_FLOAT)1.082392200); /* 2*(c2-c6) */
-    tmp12 = z5 - z10 * ((FAST_FLOAT)2.613125930); /* 2*(c2+c6) */
+    z5 = (z10 + z12) * ((FAST_FLOAT) 1.847759065); /* 2*c2 */
+    tmp10 = z5 - z12 * ((FAST_FLOAT) 1.082392200); /* 2*(c2-c6) */
+    tmp12 = z5 - z10 * ((FAST_FLOAT) 2.613125930); /* 2*(c2+c6) */

    tmp6 = tmp12 - tmp7;
    tmp5 = tmp11 - tmp6;
@@ -224,14 +224,14 @@ jpeg_idct_float(j_decompress_ptr cinfo, jpeg_component_info *compptr,

    /* Final output stage: float->int conversion and range-limit */

-    outptr[0] = range_limit[((int)(tmp0 + tmp7)) & RANGE_MASK];
-    outptr[7] = range_limit[((int)(tmp0 - tmp7)) & RANGE_MASK];
-    outptr[1] = range_limit[((int)(tmp1 + tmp6)) & RANGE_MASK];
-    outptr[6] = range_limit[((int)(tmp1 - tmp6)) & RANGE_MASK];
-    outptr[2] = range_limit[((int)(tmp2 + tmp5)) & RANGE_MASK];
-    outptr[5] = range_limit[((int)(tmp2 - tmp5)) & RANGE_MASK];
-    outptr[3] = range_limit[((int)(tmp3 + tmp4)) & RANGE_MASK];
-    outptr[4] = range_limit[((int)(tmp3 - tmp4)) & RANGE_MASK];
+    outptr[0] = range_limit[((int) (tmp0 + tmp7)) & RANGE_MASK];
+    outptr[7] = range_limit[((int) (tmp0 - tmp7)) & RANGE_MASK];
+    outptr[1] = range_limit[((int) (tmp1 + tmp6)) & RANGE_MASK];
+    outptr[6] = range_limit[((int) (tmp1 - tmp6)) & RANGE_MASK];
+    outptr[2] = range_limit[((int) (tmp2 + tmp5)) & RANGE_MASK];
+    outptr[5] = range_limit[((int) (tmp2 - tmp5)) & RANGE_MASK];
+    outptr[3] = range_limit[((int) (tmp3 + tmp4)) & RANGE_MASK];
+    outptr[4] = range_limit[((int) (tmp3 - tmp4)) & RANGE_MASK];

    wsptr += DCTSIZE;           /* advance pointer to next row */
  }
@@ -92,10 +92,10 @@
 */

 #if CONST_BITS == 8
-#define FIX_1_082392200  ((JLONG)277)           /* FIX(1.082392200) */
-#define FIX_1_414213562  ((JLONG)362)           /* FIX(1.414213562) */
-#define FIX_1_847759065  ((JLONG)473)           /* FIX(1.847759065) */
-#define FIX_2_613125930  ((JLONG)669)           /* FIX(2.613125930) */
+#define FIX_1_082392200  ((JLONG)  277)         /* FIX(1.082392200) */
+#define FIX_1_414213562  ((JLONG)  362)         /* FIX(1.414213562) */
+#define FIX_1_847759065  ((JLONG)  473)         /* FIX(1.847759065) */
+#define FIX_2_613125930  ((JLONG)  669)         /* FIX(2.613125930) */
 #else
 #define FIX_1_082392200  FIX(1.082392200)
 #define FIX_1_414213562  FIX(1.414213562)
@@ -111,7 +111,7 @@

 #ifndef USE_ACCURATE_ROUNDING
 #undef DESCALE
-#define DESCALE(x, n)  RIGHT_SHIFT(x, n)
+#define DESCALE(x,n)  RIGHT_SHIFT(x, n)
 #endif


@@ -119,7 +119,7 @@
 * descale to yield a DCTELEM result.
 */

-#define MULTIPLY(var, const)  ((DCTELEM)DESCALE((var) * (const), CONST_BITS))
+#define MULTIPLY(var,const)  ((DCTELEM) DESCALE((var) * (const), CONST_BITS))


 /* Dequantize a coefficient by multiplying it by the multiplier-table
@@ -129,10 +129,10 @@
 */

 #if BITS_IN_JSAMPLE == 8
-#define DEQUANTIZE(coef, quantval)  (((IFAST_MULT_TYPE)(coef)) * (quantval))
+#define DEQUANTIZE(coef,quantval)  (((IFAST_MULT_TYPE) (coef)) * (quantval))
 #else
-#define DEQUANTIZE(coef, quantval) \
-  DESCALE((coef) * (quantval), IFAST_SCALE_BITS - PASS1_BITS)
+#define DEQUANTIZE(coef,quantval)  \
+        DESCALE((coef)*(quantval), IFAST_SCALE_BITS-PASS1_BITS)
 #endif


@@ -147,19 +147,19 @@
 #else
 #define DCTELEMBITS  32         /* DCTELEM must be 32 bits */
 #endif
-#define IRIGHT_SHIFT(x, shft) \
-  ((ishift_temp = (x)) < 0 ? \
-   (ishift_temp >> (shft)) | ((~((DCTELEM)0)) << (DCTELEMBITS - (shft))) : \
-   (ishift_temp >> (shft)))
+#define IRIGHT_SHIFT(x,shft)  \
+    ((ishift_temp = (x)) < 0 ? \
+     (ishift_temp >> (shft)) | ((~((DCTELEM) 0)) << (DCTELEMBITS-(shft))) : \
+     (ishift_temp >> (shft)))
 #else
 #define ISHIFT_TEMPS
-#define IRIGHT_SHIFT(x, shft)   ((x) >> (shft))
+#define IRIGHT_SHIFT(x,shft)    ((x) >> (shft))
 #endif

 #ifdef USE_ACCURATE_ROUNDING
-#define IDESCALE(x, n)  ((int)IRIGHT_SHIFT((x) + (1 << ((n) - 1)), n))
+#define IDESCALE(x,n)  ((int) IRIGHT_SHIFT((x) + (1 << ((n)-1)), n))
 #else
-#define IDESCALE(x, n)  ((int)IRIGHT_SHIFT(x, n))
+#define IDESCALE(x,n)  ((int) IRIGHT_SHIFT(x, n))
 #endif


@@ -168,9 +168,9 @@
 */

 GLOBAL(void)
-jpeg_idct_ifast(j_decompress_ptr cinfo, jpeg_component_info *compptr,
-                JCOEFPTR coef_block, JSAMPARRAY output_buf,
-                JDIMENSION output_col)
+jpeg_idct_ifast (j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block,
+                 JSAMPARRAY output_buf, JDIMENSION output_col)
 {
  DCTELEM tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
  DCTELEM tmp10, tmp11, tmp12, tmp13;
@@ -188,7 +188,7 @@ jpeg_idct_ifast(j_decompress_ptr cinfo, jpeg_component_info *compptr,
  /* Pass 1: process columns from input, store into work array. */

  inptr = coef_block;
-  quantptr = (IFAST_MULT_TYPE *)compptr->dct_table;
+  quantptr = (IFAST_MULT_TYPE *) compptr->dct_table;
  wsptr = workspace;
  for (ctr = DCTSIZE; ctr > 0; ctr--) {
    /* Due to quantization, we will usually find that many of the input
@@ -200,21 +200,21 @@ jpeg_idct_ifast(j_decompress_ptr cinfo, jpeg_component_info *compptr,
     * column DCT calculations can be simplified this way.
     */

-    if (inptr[DCTSIZE * 1] == 0 && inptr[DCTSIZE * 2] == 0 &&
-        inptr[DCTSIZE * 3] == 0 && inptr[DCTSIZE * 4] == 0 &&
-        inptr[DCTSIZE * 5] == 0 && inptr[DCTSIZE * 6] == 0 &&
-        inptr[DCTSIZE * 7] == 0) {
+    if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 &&
+        inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*4] == 0 &&
+        inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*6] == 0 &&
+        inptr[DCTSIZE*7] == 0) {
      /* AC terms all zero */
-      int dcval = (int)DEQUANTIZE(inptr[DCTSIZE * 0], quantptr[DCTSIZE * 0]);
+      int dcval = (int) DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);

-      wsptr[DCTSIZE * 0] = dcval;
-      wsptr[DCTSIZE * 1] = dcval;
-      wsptr[DCTSIZE * 2] = dcval;
-      wsptr[DCTSIZE * 3] = dcval;
-      wsptr[DCTSIZE * 4] = dcval;
-      wsptr[DCTSIZE * 5] = dcval;
-      wsptr[DCTSIZE * 6] = dcval;
-      wsptr[DCTSIZE * 7] = dcval;
+      wsptr[DCTSIZE*0] = dcval;
+      wsptr[DCTSIZE*1] = dcval;
+      wsptr[DCTSIZE*2] = dcval;
+      wsptr[DCTSIZE*3] = dcval;
+      wsptr[DCTSIZE*4] = dcval;
+      wsptr[DCTSIZE*5] = dcval;
+      wsptr[DCTSIZE*6] = dcval;
+      wsptr[DCTSIZE*7] = dcval;

      inptr++;                  /* advance pointers to next column */
      quantptr++;
@@ -224,10 +224,10 @@ jpeg_idct_ifast(j_decompress_ptr cinfo, jpeg_component_info *compptr,

    /* Even part */

-    tmp0 = DEQUANTIZE(inptr[DCTSIZE * 0], quantptr[DCTSIZE * 0]);
-    tmp1 = DEQUANTIZE(inptr[DCTSIZE * 2], quantptr[DCTSIZE * 2]);
-    tmp2 = DEQUANTIZE(inptr[DCTSIZE * 4], quantptr[DCTSIZE * 4]);
-    tmp3 = DEQUANTIZE(inptr[DCTSIZE * 6], quantptr[DCTSIZE * 6]);
+    tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
+    tmp1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
+    tmp2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
+    tmp3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);

    tmp10 = tmp0 + tmp2;        /* phase 3 */
    tmp11 = tmp0 - tmp2;
@@ -242,10 +242,10 @@ jpeg_idct_ifast(j_decompress_ptr cinfo, jpeg_component_info *compptr,

    /* Odd part */

-    tmp4 = DEQUANTIZE(inptr[DCTSIZE * 1], quantptr[DCTSIZE * 1]);
-    tmp5 = DEQUANTIZE(inptr[DCTSIZE * 3], quantptr[DCTSIZE * 3]);
-    tmp6 = DEQUANTIZE(inptr[DCTSIZE * 5], quantptr[DCTSIZE * 5]);
-    tmp7 = DEQUANTIZE(inptr[DCTSIZE * 7], quantptr[DCTSIZE * 7]);
+    tmp4 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
+    tmp5 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
+    tmp6 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
+    tmp7 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);

    z13 = tmp6 + tmp5;          /* phase 6 */
    z10 = tmp6 - tmp5;
@@ -257,20 +257,20 @@ jpeg_idct_ifast(j_decompress_ptr cinfo, jpeg_component_info *compptr,

    z5 = MULTIPLY(z10 + z12, FIX_1_847759065); /* 2*c2 */
    tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5; /* 2*(c2-c6) */
-    tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5; /* -2*(c2+c6) */
+    tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5; /* -2*(c2+c6) */

    tmp6 = tmp12 - tmp7;        /* phase 2 */
    tmp5 = tmp11 - tmp6;
    tmp4 = tmp10 + tmp5;

-    wsptr[DCTSIZE * 0] = (int)(tmp0 + tmp7);
-    wsptr[DCTSIZE * 7] = (int)(tmp0 - tmp7);
-    wsptr[DCTSIZE * 1] = (int)(tmp1 + tmp6);
-    wsptr[DCTSIZE * 6] = (int)(tmp1 - tmp6);
-    wsptr[DCTSIZE * 2] = (int)(tmp2 + tmp5);
-    wsptr[DCTSIZE * 5] = (int)(tmp2 - tmp5);
-    wsptr[DCTSIZE * 4] = (int)(tmp3 + tmp4);
-    wsptr[DCTSIZE * 3] = (int)(tmp3 - tmp4);
+    wsptr[DCTSIZE*0] = (int) (tmp0 + tmp7);
+    wsptr[DCTSIZE*7] = (int) (tmp0 - tmp7);
+    wsptr[DCTSIZE*1] = (int) (tmp1 + tmp6);
+    wsptr[DCTSIZE*6] = (int) (tmp1 - tmp6);
+    wsptr[DCTSIZE*2] = (int) (tmp2 + tmp5);
+    wsptr[DCTSIZE*5] = (int) (tmp2 - tmp5);
+    wsptr[DCTSIZE*4] = (int) (tmp3 + tmp4);
+    wsptr[DCTSIZE*3] = (int) (tmp3 - tmp4);

    inptr++;                    /* advance pointers to next column */
    quantptr++;
@@ -296,8 +296,8 @@ jpeg_idct_ifast(j_decompress_ptr cinfo, jpeg_component_info *compptr,
    if (wsptr[1] == 0 && wsptr[2] == 0 && wsptr[3] == 0 && wsptr[4] == 0 &&
        wsptr[5] == 0 && wsptr[6] == 0 && wsptr[7] == 0) {
      /* AC terms all zero */
-      JSAMPLE dcval =
-        range_limit[IDESCALE(wsptr[0], PASS1_BITS + 3) & RANGE_MASK];
+      JSAMPLE dcval = range_limit[IDESCALE(wsptr[0], PASS1_BITS+3)
+                                  & RANGE_MASK];

      outptr[0] = dcval;
      outptr[1] = dcval;
@@ -315,12 +315,12 @@ jpeg_idct_ifast(j_decompress_ptr cinfo, jpeg_component_info *compptr,

    /* Even part */

-    tmp10 = ((DCTELEM)wsptr[0] + (DCTELEM)wsptr[4]);
-    tmp11 = ((DCTELEM)wsptr[0] - (DCTELEM)wsptr[4]);
+    tmp10 = ((DCTELEM) wsptr[0] + (DCTELEM) wsptr[4]);
+    tmp11 = ((DCTELEM) wsptr[0] - (DCTELEM) wsptr[4]);

-    tmp13 = ((DCTELEM)wsptr[2] + (DCTELEM)wsptr[6]);
-    tmp12 =
-      MULTIPLY((DCTELEM)wsptr[2] - (DCTELEM)wsptr[6], FIX_1_414213562) - tmp13;
+    tmp13 = ((DCTELEM) wsptr[2] + (DCTELEM) wsptr[6]);
+    tmp12 = MULTIPLY((DCTELEM) wsptr[2] - (DCTELEM) wsptr[6], FIX_1_414213562)
+            - tmp13;

    tmp0 = tmp10 + tmp13;
    tmp3 = tmp10 - tmp13;
@@ -329,17 +329,17 @@ jpeg_idct_ifast(j_decompress_ptr cinfo, jpeg_component_info *compptr,

    /* Odd part */

-    z13 = (DCTELEM)wsptr[5] + (DCTELEM)wsptr[3];
-    z10 = (DCTELEM)wsptr[5] - (DCTELEM)wsptr[3];
-    z11 = (DCTELEM)wsptr[1] + (DCTELEM)wsptr[7];
-    z12 = (DCTELEM)wsptr[1] - (DCTELEM)wsptr[7];
+    z13 = (DCTELEM) wsptr[5] + (DCTELEM) wsptr[3];
+    z10 = (DCTELEM) wsptr[5] - (DCTELEM) wsptr[3];
+    z11 = (DCTELEM) wsptr[1] + (DCTELEM) wsptr[7];
+    z12 = (DCTELEM) wsptr[1] - (DCTELEM) wsptr[7];

    tmp7 = z11 + z13;           /* phase 5 */
    tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562); /* 2*c4 */

    z5 = MULTIPLY(z10 + z12, FIX_1_847759065); /* 2*c2 */
    tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5; /* 2*(c2-c6) */
-    tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5; /* -2*(c2+c6) */
+    tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5; /* -2*(c2+c6) */

    tmp6 = tmp12 - tmp7;        /* phase 2 */
    tmp5 = tmp11 - tmp6;
@@ -347,22 +347,22 @@ jpeg_idct_ifast(j_decompress_ptr cinfo, jpeg_component_info *compptr,

    /* Final output stage: scale down by a factor of 8 and range-limit */

-    outptr[0] =
-      range_limit[IDESCALE(tmp0 + tmp7, PASS1_BITS + 3) & RANGE_MASK];
-    outptr[7] =
-      range_limit[IDESCALE(tmp0 - tmp7, PASS1_BITS + 3) & RANGE_MASK];
-    outptr[1] =
-      range_limit[IDESCALE(tmp1 + tmp6, PASS1_BITS + 3) & RANGE_MASK];
-    outptr[6] =
-      range_limit[IDESCALE(tmp1 - tmp6, PASS1_BITS + 3) & RANGE_MASK];
-    outptr[2] =
-      range_limit[IDESCALE(tmp2 + tmp5, PASS1_BITS + 3) & RANGE_MASK];
-    outptr[5] =
-      range_limit[IDESCALE(tmp2 - tmp5, PASS1_BITS + 3) & RANGE_MASK];
-    outptr[4] =
-      range_limit[IDESCALE(tmp3 + tmp4, PASS1_BITS + 3) & RANGE_MASK];
-    outptr[3] =
-      range_limit[IDESCALE(tmp3 - tmp4, PASS1_BITS + 3) & RANGE_MASK];
+    outptr[0] = range_limit[IDESCALE(tmp0 + tmp7, PASS1_BITS+3)
+                            & RANGE_MASK];
+    outptr[7] = range_limit[IDESCALE(tmp0 - tmp7, PASS1_BITS+3)
+                            & RANGE_MASK];
+    outptr[1] = range_limit[IDESCALE(tmp1 + tmp6, PASS1_BITS+3)
+                            & RANGE_MASK];
+    outptr[6] = range_limit[IDESCALE(tmp1 - tmp6, PASS1_BITS+3)
+                            & RANGE_MASK];
+    outptr[2] = range_limit[IDESCALE(tmp2 + tmp5, PASS1_BITS+3)
+                            & RANGE_MASK];
+    outptr[5] = range_limit[IDESCALE(tmp2 - tmp5, PASS1_BITS+3)
+                            & RANGE_MASK];
+    outptr[4] = range_limit[IDESCALE(tmp3 + tmp4, PASS1_BITS+3)
+                            & RANGE_MASK];
+    outptr[3] = range_limit[IDESCALE(tmp3 - tmp4, PASS1_BITS+3)
+                            & RANGE_MASK];

    wsptr += DCTSIZE;           /* advance pointer to next row */
  }
--- a/Show More
+++ b/Show More