launcher: better DLL logging and remove ucrt hack (#919 )

## Link to GitHub Issue or related Pull Request, if one exists n/a ## Description of change Remove workaround implemented in #264 that added an ugly hack to work around DLL hooks that rely on spice using MSVCRT (failure to obtain argc/argv). Update the logic that prints info about DLL overrides so that it tries to print out as much info as possible, instead of bailing out early if something is missing. ## Testing
sdk: get/set coin blocker (#918 )
2026-10-05 09:48:11 -07:00 · 2026-10-03 14:14:22 -07:00 · 2026-09-22 21:42:34 -07:00 · 2026-09-17 14:19:03 -07:00 · 2026-09-12 09:51:23 -07:00 · 2026-09-12 09:50:36 -07:00
320 changed files with 13739 additions and 86308 deletions
@@ -29,4 +29,33 @@ jobs:
        with:
          name: spice2x-ci-${{ env.COMMIT_SHORT_SHA }}
          path: src/spice2x/bin
-          if-no-files-found: error
+          if-no-files-found: error
+
+  msvc-ci:
+    name: Build (MSVC ${{ matrix.arch }}-bit)
+    # windows-latest ships Visual Studio 2026; pin to the VS 2022 image, which is
+    # the toolset spice2x is actually developed against
+    runs-on: windows-2022
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - arch: 32
+            platform: Win32
+            target: spicetools_spice spicetools_cfg
+          - arch: 64
+            platform: x64
+            target: spicetools_spice64
+    defaults:
+      run:
+        working-directory: ./src/spice2x
+    steps:
+      - uses: actions/checkout@v5
+      - name: Configure
+        run: >
+          cmake -S . -B cmake-build-msvc-${{ matrix.arch }}
+          -A ${{ matrix.platform }}
+      - name: Compile
+        run: >
+          cmake --build cmake-build-msvc-${{ matrix.arch }}
+          --config Release --target ${{ matrix.target }}
@@ -22,6 +22,7 @@ To contribute, fork the repo (just the main branch), make changes in your fork,
 * Any additions to built-in patches (modifications / removals are OK if we have a good reason).
 * Changes to the software license terms.
 * Localization / translation for UI text. It becomes too difficult to manage by the maintainers.
+* Bundling third party DLL binary; e.g., Discord Social SDK, PC light control integration, and so on. These should be built as hook DLLs instead, optionally with [Spice SDK](https://github.com/spice2x/spice2x.github.io/wiki/Spice-SDK).

 ### Avoiding regressions

@@ -104,5 +105,5 @@ if (conditional)
  * We don't use GSL.
  * Don't throw exceptions.
  * Stick to smart pointers. For interfacing with C Win32 API and raw buffers, use `unique_plain_ptr`.
-  * Writing in C is also completely acceptable.
+  * Writing in C is also completely acceptable but prefer to use RAII patterns.
 * Other than that, there are no strict rules for code formatting, but please attempt to emulate the style around the code you are modifying.
@@ -56,6 +56,10 @@ We explicitly do **NOT** have a Discord server for dicussions - we try to do eve

 Please see [CONTRIBUTING page](https://github.com/spice2x/spice2x.github.io/blob/main/CONTRIBUTING.md) for a full list of guidelines when submitting code.

+### AI-Use Policy
+
+Use AI tools at your discretion, but remember that a human will review every issue and pull request. Please ensure submissions are accurate, relevant, and worth the reviewer’s time.
+
 ## Additional information

 Please read [README.md](https://github.com/spice2x/spice2x.github.io/blob/main/src/spice2x/README.md) inside `src/spice2x`.
@@ -254,20 +254,50 @@ add_subdirectory(external/discord-rpc EXCLUDE_FROM_ALL)
 add_subdirectory(external/hash-library EXCLUDE_FROM_ALL)
 add_subdirectory(external/imgui EXCLUDE_FROM_ALL)
 add_subdirectory(external/minhook EXCLUDE_FROM_ALL)
+add_subdirectory(external/wslay EXCLUDE_FROM_ALL)
 add_subdirectory(external/cpu_features EXCLUDE_FROM_ALL)

-# libjpeg-turbo's SIMD needs nasm; enable_language belongs at top level. Without
-# it the library still builds, just without SIMD.
-include(CheckLanguage)
-check_language(ASM_NASM)
-if(CMAKE_ASM_NASM_COMPILER)
-    enable_language(ASM_NASM)
-else()
-    message(WARNING
-            "nasm not found: libjpeg-turbo will be built without SIMD, "
-            "which makes api screen capture several times slower")
+# libjpeg-turbo, prebuilt into the deps image. The WinXP toolchains have their own
+# sysroot and cannot see it, so those targets build without JPEG support.
+add_library(spice_jpeg INTERFACE)
+if(NOT SPICE_XP)
+    # search static archives only: the mingw package also ships an import library,
+    # and linking that one would pull in a libjpeg DLL at runtime
+    set(SPICE_JPEG_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES})
+    set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_STATIC_LIBRARY_SUFFIX})
+    find_package(JPEG)
+    set(CMAKE_FIND_LIBRARY_SUFFIXES ${SPICE_JPEG_SUFFIXES})
+
+    if(JPEG_FOUND)
+        target_link_libraries(spice_jpeg INTERFACE JPEG::JPEG)
+        target_compile_definitions(spice_jpeg INTERFACE SPICE_JPEG=1)
+    else()
+        message(WARNING
+                "libjpeg-turbo not found: screen capture over the API is disabled")
+    endif()
+endif()
+
+# x264 for the API H.264 video stream, installed into the mingw sysroots by the
+# deps image. The WinXP toolchains deliberately go without it and serve MJPEG only.
+add_library(spice_x264 INTERFACE)
+if(NOT SPICE_XP)
+    # search static archives only: the mingw package also ships an import library,
+    # and linking that one would pull in a libx264 DLL at runtime
+    set(SPICE_X264_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES})
+    set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_STATIC_LIBRARY_SUFFIX})
+    find_library(X264_LIBRARY NAMES x264 libx264)
+    set(CMAKE_FIND_LIBRARY_SUFFIXES ${SPICE_X264_SUFFIXES})
+
+    find_path(X264_INCLUDE_DIR NAMES x264.h)
+    if(X264_LIBRARY AND X264_INCLUDE_DIR)
+        target_include_directories(spice_x264 INTERFACE "${X264_INCLUDE_DIR}")
+        target_link_libraries(spice_x264 INTERFACE "${X264_LIBRARY}")
+        target_compile_definitions(spice_x264 INTERFACE SPICE_H264=1)
+    else()
+        message(WARNING
+                "x264 not found: the api video stream will only offer MJPEG")
+    endif()
 endif()
-add_subdirectory(external/libjpeg-turbo EXCLUDE_FROM_ALL)

 # fpng's SIMD needs the whole unit built for SSE4.1, which its runtime CPU check
 # cannot undo, so keep it scalar rather than raising the CPU baseline
@@ -339,6 +369,10 @@ set(SOURCE_FILES ${SOURCE_FILES}
        # api
        api/controller.cpp
        api/websocket.cpp
+        api/capture_pump.cpp
+        api/h264_stream.cpp
+        api/stream_format.cpp
+        api/stream_server.cpp
        api/request.cpp
        api/response.cpp
        api/module.cpp
@@ -486,6 +520,7 @@ set(SOURCE_FILES ${SOURCE_FILES}
        games/scotto/io.cpp
        games/drs/drs.cpp
        games/drs/io.cpp
+        games/drs/motion_cam.cpp
        games/drs/rgb_cam.cpp
        games/we/we.cpp
        games/we/io.cpp
@@ -497,6 +532,7 @@ set(SOURCE_FILES ${SOURCE_FILES}
        games/otoca/p4io.cpp
        games/silentscope/silentscope.cpp
        games/silentscope/io.cpp
+        games/silentscope/projector.cpp
        games/pcm/pcm.cpp
        games/pcm/io.cpp
        games/onpara/onpara.cpp
@@ -518,6 +554,9 @@ set(SOURCE_FILES ${SOURCE_FILES}
        games/pc/pc.cpp
        games/pc/io.cpp
        games/pc/bi2x_hook.cpp
+        games/udn/udn.cpp
+        games/udn/io.cpp
+        games/udn/bi2x_hook.cpp

        # hooks
        hooks/audio/acm.cpp
@@ -569,6 +608,7 @@ set(SOURCE_FILES ${SOURCE_FILES}
        hooks/graphics/backends/d3d9/d3d9_texture.cpp
        hooks/graphics/backends/d3d11/d3d11_backend.cpp
        hooks/graphics/backends/d3d11/d3d11_swapchain.cpp
+        hooks/graphics/backends/d3d11/d3d11_swapchain_udn.cpp
        hooks/graphics/backends/d3d11/d3d11_factory.cpp
        hooks/graphics/backends/d3d11/d3d11_vtable_capture.cpp
        hooks/graphics/backends/d3d11/d3d11_screenshot.cpp
@@ -580,6 +620,8 @@ set(SOURCE_FILES ${SOURCE_FILES}
        hooks/networkhook.cpp
        hooks/icmphook_net.cpp
        hooks/icmphook_iphlpapi.cpp
+        hooks/nicspoof.cpp
+        hooks/nicspoof_tunnel.cpp
        hooks/powrprof.cpp
        #hooks/rom.cpp
        hooks/setupapihook.cpp
@@ -681,6 +723,8 @@ set(SOURCE_FILES ${SOURCE_FILES}
        reader/crypt.cpp

        # sdk
+        sdk/d3d9.cpp
+        sdk/modules.cpp
        sdk/sdk.cpp

        # stubs
@@ -764,7 +808,7 @@ endfunction()
 add_library(spicetools_spice_objs OBJECT ${SOURCE_FILES})
 target_link_libraries(spicetools_spice_objs
        PUBLIC d3d9 ws2_32 version comctl32 shlwapi iphlpapi hid secur32 setupapi psapi winmm winhttp
-        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook imm32 dwmapi CpuFeatures::cpu_features jpeg-static)
+        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook wslay imm32 dwmapi CpuFeatures::cpu_features spice_jpeg spice_x264)
 target_link_libraries(spicetools_spice_objs PUBLIC winscard)

 if(NOT MSVC)
@@ -804,7 +848,7 @@ set(RESOURCE_FILES build/manifest.manifest build/manifest.rc build/icon.rc cfg/W
 add_executable(spicetools_spice_linux ${SOURCE_FILES} ${RESOURCE_FILES})
 target_link_libraries(spicetools_spice_linux
        PUBLIC d3d9 ws2_32 version comctl32 shlwapi iphlpapi hid secur32 setupapi psapi winmm winhttp
-        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook imm32 dwmapi CpuFeatures::cpu_features jpeg-static)
+        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook wslay imm32 dwmapi CpuFeatures::cpu_features spice_jpeg spice_x264)
 set_target_properties(spicetools_spice_linux PROPERTIES PREFIX "")
 set_target_properties(spicetools_spice_linux PROPERTIES OUTPUT_NAME "spice_linux")
 target_compile_definitions(spicetools_spice_linux PRIVATE NO_SCARD=1 PRIVATE SPICE_LINUX=1)
@@ -822,7 +866,7 @@ add_executable(spicetools_spice64 ${SOURCE_FILES} ${RESOURCE_FILES})
 # do NOT link against: mf, mfplat, mfreadwrite; otherwise unity games will break
 target_link_libraries(spicetools_spice64
        PUBLIC d3d9 ws2_32 version comctl32 shlwapi iphlpapi hid secur32 setupapi psapi winmm winhttp mfuuid strmiids dxva2
-        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook imm32 dwmapi CpuFeatures::cpu_features jpeg-static)
+        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook wslay imm32 dwmapi CpuFeatures::cpu_features spice_jpeg spice_x264)
 target_link_libraries(spicetools_spice64 PUBLIC winscard)
 set_target_properties(spicetools_spice64 PROPERTIES PREFIX "")
 set_target_properties(spicetools_spice64 PROPERTIES OUTPUT_NAME "spice64")
@@ -845,7 +889,7 @@ add_executable(spicetools_spice64_linux ${SOURCE_FILES} ${RESOURCE_FILES})
 # do NOT link against: mf, mfplat, mfreadwrite; otherwise unity games will break
 target_link_libraries(spicetools_spice64_linux
        PUBLIC d3d9 ws2_32 version comctl32 shlwapi iphlpapi hid secur32 setupapi psapi winmm winhttp mfuuid strmiids dxva2
-        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook imm32 dwmapi CpuFeatures::cpu_features jpeg-static)
+        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook wslay imm32 dwmapi CpuFeatures::cpu_features spice_jpeg spice_x264)
 set_target_properties(spicetools_spice64_linux PROPERTIES PREFIX "")
 set_target_properties(spicetools_spice64_linux PROPERTIES OUTPUT_NAME "spice64_linux")
 target_compile_definitions(spicetools_spice64_linux PRIVATE SPICE64=1)
@@ -864,9 +908,10 @@ endif()
 set(SOURCE_FILES ${SOURCE_FILES} launcher/options.h launcher/options.cpp)
 set(RESOURCE_FILES cfg/manifest.manifest cfg/manifest.rc cfg/icon.rc cfg/Win32D.rc)
 add_executable(spicetools_cfg WIN32 ${SOURCE_FILES} ${RESOURCE_FILES})
+# the configurator serves neither the API nor the video stream, so it needs no codecs
 target_link_libraries(spicetools_cfg
        PUBLIC d3d9 ws2_32 version comctl32 shlwapi iphlpapi hid secur32 setupapi psapi winmm winhttp strmiids
-        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook imm32 dwmapi CpuFeatures::cpu_features jpeg-static)
+        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook wslay imm32 dwmapi CpuFeatures::cpu_features)
 target_link_libraries(spicetools_cfg PUBLIC winscard)
 set_target_properties(spicetools_cfg PROPERTIES PREFIX "")
 set_target_properties(spicetools_cfg PROPERTIES OUTPUT_NAME "spicecfg")
@@ -884,7 +929,7 @@ set(RESOURCE_FILES cfg/manifest.manifest cfg/manifest.rc cfg/icon.rc cfg/Win32D.
 add_executable(spicetools_cfg_linux WIN32 ${SOURCE_FILES} ${RESOURCE_FILES})
 target_link_libraries(spicetools_cfg_linux
        PUBLIC d3d9 ws2_32 version comctl32 shlwapi iphlpapi hid secur32 setupapi psapi winmm winhttp strmiids
-        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook imm32 dwmapi CpuFeatures::cpu_features jpeg-static)
+        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook wslay imm32 dwmapi CpuFeatures::cpu_features)
 set_target_properties(spicetools_cfg_linux PROPERTIES PREFIX "")
 set_target_properties(spicetools_cfg_linux PROPERTIES OUTPUT_NAME "spicecfg_linux")
 target_compile_definitions(spicetools_cfg_linux PRIVATE SPICETOOLS_SPICECFG_STANDALONE=1)
@@ -1008,8 +1053,16 @@ if(NOT MSVC)
 endif()

 # sdk_sample_v0_cpp.dll (64 bit)
-set(SOURCE_FILES sdk/sample/v0/cpp/v0_cpp.cpp)
+set(SOURCE_FILES
+    sdk/sample/v0/cpp/v0_cpp.cpp
+    sdk/sample/v0/cpp/v0_cpp_imgui.cpp
+    external/imgui/imgui.cpp
+    external/imgui/imgui_draw.cpp
+    external/imgui/imgui_tables.cpp
+    external/imgui/imgui_widgets.cpp
+    external/imgui/backends/imgui_impl_dx9.cpp)
 add_library(spicetools_sdk_sample_v0_cpp_64 SHARED ${SOURCE_FILES} ${RESOURCE_FILES} sdk/sample/v0/cpp/v0_cpp.def)
+target_link_libraries(spicetools_sdk_sample_v0_cpp_64 PRIVATE imm32)
 set_target_properties(spicetools_sdk_sample_v0_cpp_64 PROPERTIES PREFIX "")
 set_target_properties(spicetools_sdk_sample_v0_cpp_64 PROPERTIES OUTPUT_NAME "sdk_sample_v0_cpp")

@@ -127,7 +127,30 @@ doesn't matter since the TCP protocol doesn't allow for out of order data,
 however this may change when/if support for UDP is being introduced. The only
 restriction is that the ID has to be a valid 64-bit unsigned integer.

+#### Capture
+- get_screens()
+  - returns the screen numbers the game has registered for capture
+- get_jpg(screen: uint, quality: uint, divide: uint)
+  - returns the timestamp, width, height and base64 encoded JPEG of one screen
+  - all parameters are optional and default to screen 0, quality 70, divide 1
+  - divide shrinks the image by that factor before encoding
+- get_streams()
+  - returns a dict describing the HTTP video stream, or no data at all when
+    `-apistream` is not enabled and there is nothing to describe
+  - `port` is the stream server port
+  - `formats` lists the wire formats this build serves, each with a `name`
+    (`h264` or `mjpeg`) and the `path` to request them on
+  - `screens` lists every capturable screen with its `width`, `height`, and
+    `busy`
+
 #### Card
+- get_cards()
+  - returns the current card ID and source for each active card reader
+  - each entry contains `index`, `card_id`, and `source`
+  - `source` is `file` or `override`
+  - file entries also contain `file_name`, without the full configured path
+  - `-card0` and `-card1` overrides do not contain `file_name`
+  - this function only works when an API password is configured
 - insert(index: uint, card_id: hex)
  - inserts a card which gets read by the emulated card readers for the game
  - index has to be either 0 (for P1) or 1 (for P2)
@@ -291,6 +314,47 @@ which also means that your hex edits are applicable directly.
 - image_resize_set_scene(scene: int)
  - sets the active scene for image resize state; set to 0 to disable resize

+## Video Stream
+
+Separate from the JSON API, spice can serve the mirrored screen as a video
+stream over plain HTTP. Enable it with `-apistream`. It listens on the API port
+plus two, in the same way the WebSocket server uses the API port plus one, so
+`-api 1337` puts the stream on 1339. This means `-api` has to be enabled too.
+
+Rather than working the port out, clients should ask the JSON API for it with
+`capture.get_streams()`, which also reports which of the formats below this
+build serves, the size of each screen and whether one is already taken.
+
+Two formats are served:
+
+    http://host:1339/stream.mjpg    JPEG frames, multipart/x-mixed-replace
+    http://host:1339/stream.h264    H.264 annex-b, no container
+
+All accept the same optional query parameters:
+
+- `screen` - which screen to mirror, 0-3. Defaults to the subscreen when the
+  game has one, otherwise the main screen.
+- `fps` - frames per second, 1-60. Default 30.
+- `q` - quality, 1-100. Default 70. This is the JPEG quality for `stream.mjpg`
+  and is mapped onto the H.264 rate factor for `stream.h264`, so the same number
+  does not mean the same thing for both.
+
+For example:
+
+    http://host:1339/stream.h264?screen=1&fps=30&q=70
+
+See the wiki for format tradeoffs, latency tuning, testing commands and client
+notes.
+
+The stream is view only. Touch and other input still go through the JSON API,
+so a companion app needs both. There is no authentication on the stream port -
+anyone who can reach it can watch the screen.
+
+WinXP builds have no video stream. Neither encoder is compiled in, so nothing
+listens on the stream port even with `-apistream`, `capture.get_streams()`
+returns no data, and the JSON API's JPEG screen capture is unavailable for the
+same reason.
+
 ## Native wrapper libraries
 Spicetools provides wrapper libraries in: Arduino, C++, Dart, and Python.
 Python is the only one that is fully spec compliant.
@@ -1,5 +1,7 @@
 #include "bmpu.h"

+#include <algorithm>
+
 #include "acio/icca/icca.h"
 #include "avs/game.h"
 #include "cfg/api.h"
@@ -9,6 +11,7 @@
 #include "games/ftt/io.h"
 #include "games/museca/io.h"
 #include "games/silentscope/io.h"
+#include "hooks/graphics/graphics.h"
 #include "launcher/launcher.h"
 #include "misc/eamuse.h"

@@ -530,15 +533,38 @@ static bool __cdecl ac_io_bmpu_update_control_status_buffer() {
            STATUS_BUFFER[4] |= 0x20;
        }

-        // joy stick raw input
+        // gun position, sent big endian; the game keeps the top 12 bits of each pair
        auto &analogs = games::silentscope::get_analogs();
+        auto &gun_x = analogs.at(games::silentscope::Analogs::GUN_X);
+        auto &gun_y = analogs.at(games::silentscope::Analogs::GUN_Y);
        unsigned short joy_x = 0x7FFF;
        unsigned short joy_y = 0x7FFF;
-        if (analogs.at(games::silentscope::Analogs::GUN_X).isSet()) {
-            joy_x = (unsigned short) (Analogs::getState(RI_MGR, analogs.at(games::silentscope::Analogs::GUN_X)) * USHRT_MAX);
-        }
-        if (analogs.at(games::silentscope::Analogs::GUN_Y).isSet()) {
-            joy_y = (unsigned short) (Analogs::getState(RI_MGR, analogs.at(games::silentscope::Analogs::GUN_Y)) * USHRT_MAX);
+
+        if (gun_x.isSet() || gun_y.isSet()) {
+            if (gun_x.isSet()) {
+                joy_x = (unsigned short) (Analogs::getState(RI_MGR, gun_x) * USHRT_MAX);
+            }
+            if (gun_y.isSet()) {
+                joy_y = (unsigned short) (Analogs::getState(RI_MGR, gun_y) * USHRT_MAX);
+            }
+        } else {
+
+            // the gun reports where it is aimed, which a relative pointer cannot express - the
+            // calibration screen asks for the screen centre and two corners, so read the cursor
+            POINT cursor {};
+            RECT client {};
+            POINT origin {};
+            if (NDD_MAIN_WINDOW != nullptr &&
+                GetCursorPos(&cursor) &&
+                GetClientRect(NDD_MAIN_WINDOW, &client) &&
+                ClientToScreen(NDD_MAIN_WINDOW, &origin) &&
+                client.right > 1 && client.bottom > 1)
+            {
+                const LONG x = std::clamp(cursor.x - origin.x, 0L, client.right - 1);
+                const LONG y = std::clamp(cursor.y - origin.y, 0L, client.bottom - 1);
+                joy_x = (unsigned short) (x * USHRT_MAX / (client.right - 1));
+                joy_y = (unsigned short) (y * USHRT_MAX / (client.bottom - 1));
+            }
        }

        // invert X axis
@@ -118,11 +118,11 @@ static inline void update_card(int unit_id) {
    const bool card_presented = eamuse_card_insert_consume(icca_get_active_count(), unit_id);
    const bool key_pressed = (kb_insert_press && !kb_insert_press_old[unit_id]);

-    // beatstream and nostalgia have logic that requires ac_io_icca_get_uid_felica to return the
+    // beatstream, nostalgia and Dance Evolution have logic that requires ac_io_icca_get_uid_felica to return the
    // exact same card number multiple times in a row in order for the card number to be read...
    // for whatever reason setting this to 3-4 doesn't work the very first time the game boots up
    // so we use 10 just to be safe
-    const bool need_felica_retries = avs::game::is_model({"NBT", "PAN"});
+    const bool need_felica_retries = avs::game::is_model({"KDM", "NBT", "PAN"});
    if (need_felica_retries && (card_presented || key_pressed)) {
        unit->felica_retries = 10;
    }
@@ -0,0 +1,59 @@
+#include "capture_pump.h"
+
+#include <array>
+#include <atomic>
+#include <mutex>
+
+#include "hooks/graphics/graphics.h"
+
+namespace api::capture_pump {
+
+    namespace {
+
+        std::array<std::mutex, GRAPHICS_CAPTURE_SCREEN_NO> CONSUMER_M;
+
+        // read once per capture from the present thread, so it stays lock free
+        std::atomic<bool> CLAIMED[GRAPHICS_CAPTURE_SCREEN_NO] {};
+
+        bool valid_screen(int screen) {
+            return 0 <= screen && screen < static_cast<int>(GRAPHICS_CAPTURE_SCREEN_NO);
+        }
+    }
+
+    bool capture_direct(int screen, std::shared_ptr<uint8_t[]> &out, int divide,
+            uint64_t *timestamp, int *width, int *height) {
+
+        if (!valid_screen(screen)) {
+            return false;
+        }
+
+        std::lock_guard<std::mutex> lock(CONSUMER_M[screen]);
+        graphics_capture_trigger(screen);
+        return graphics_capture_receive_raw(
+                screen, out, divide, timestamp, width, height);
+    }
+
+    bool claim_screen(int screen) {
+        if (!valid_screen(screen)) {
+            return false;
+        }
+
+        return !CLAIMED[screen].exchange(true);
+    }
+
+    void release_screen(int screen) {
+        if (!valid_screen(screen)) {
+            return;
+        }
+
+        CLAIMED[screen] = false;
+    }
+
+    bool screen_claimed(int screen) {
+        if (!valid_screen(screen)) {
+            return false;
+        }
+
+        return CLAIMED[screen];
+    }
+}
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+
+namespace api::capture_pump {
+
+    struct Frame {
+        // packed 24bpp RGB, width * height * 3 bytes
+        std::shared_ptr<uint8_t[]> pixels;
+        uint64_t timestamp = 0;
+        int width = 0;
+        int height = 0;
+    };
+
+    // the graphics layer has one capture slot per screen, so concurrent waiters would steal
+    // each other's frames; everything that captures goes through here to keep it serialized
+    bool capture_direct(int screen, std::shared_ptr<uint8_t[]> &out, int divide,
+            uint64_t *timestamp = nullptr, int *width = nullptr, int *height = nullptr);
+
+    // a screen carries one stream at a time; false when another connection already holds it
+    bool claim_screen(int screen);
+    void release_screen(int screen);
+
+    // true while a video stream client holds this screen
+    bool screen_claimed(int screen);
+}
@@ -8,6 +8,7 @@
 #include "client.h"
 #include "cfg/configurator.h"
 #include "external/rapidjson/document.h"
+#include "external/rapidjson/error/en.h"
 #include "util/crypt.h"
 #include "util/logging.h"
 #include "util/utils.h"
@@ -92,6 +93,7 @@ Controller::Controller(unsigned short port, std::string password, bool pretty)
    // bind socket to address
    if (bind(this->server, (sockaddr *) &server_address, sizeof(sockaddr)) == -1) {
        log_warning("api", "could not bind socket on port {}: {}", port, get_last_error_string());
+        closesocket(this->server);
        this->server = INVALID_SOCKET;
        if (!cfg::CONFIGURATOR_STANDALONE) {
            log_fatal("api", "failed to start server");
@@ -102,6 +104,7 @@ Controller::Controller(unsigned short port, std::string password, bool pretty)
    // set socket to listen
    if (listen(this->server, server_backlog) == -1) {
        log_warning("api", "could not listen to socket on port {}: {}", port, get_last_error_string());
+        closesocket(this->server);
        this->server = INVALID_SOCKET;
        if (!cfg::CONFIGURATOR_STANDALONE) {
            log_fatal("api", "failed to start server");
@@ -312,6 +315,8 @@ bool Controller::process_request(ClientState *state, const char *in, size_t in_s

    // check for parse error
    if (document.HasParseError()) {
+        log_warning("api", "Request JSON parse error: {} (byte offset {}, decrypted request length {} bytes)",
+            GetParseError_En(document.GetParseError()), document.GetErrorOffset(), in_size);

        // return empty response and close connection
        out->push_back(0);
@@ -337,9 +342,11 @@ bool Controller::process_request(ClientState *state, const char *in, size_t in_s
            if (module->name == request.module) {
                module_found = true;

-                // check password force
-                if (module->password_force && this->password.empty() && request.function != "session_refresh") {
-                    Value err("Module requires the password to be set.");
+                // check password requirement
+                if (module->requires_password(request.function)
+                        && this->password.empty()
+                        && request.function != "session_refresh") {
+                    Value err("Function requires the password to be set.");
                    response.add_error(err);
                    break;
                }
@@ -441,7 +448,9 @@ void Controller::free_socket() {
        this->server = INVALID_SOCKET;
    }

-    this->websocket->free_socket();
+    if (this->websocket) {
+        this->websocket->free_socket();
+    }

    for (auto &s : this->serial) {
        s->free_port();
@@ -41,21 +41,21 @@ namespace api {
        bool pretty;

        // server
-        WebSocketController *websocket;
+        WebSocketController *websocket = nullptr;
        std::vector<SerialController *> serial;
        std::vector<std::thread> server_workers;
        std::vector<std::thread> server_handlers;
        std::mutex server_handlers_m;
        std::vector<api::ClientState *> client_states;
        std::mutex client_states_m;
-        SOCKET server;
+        SOCKET server = INVALID_SOCKET;
        void server_worker();
        void connection_handler(ClientState client_state);

    public:

        // state
-        bool server_running;
+        bool server_running = false;

        // constructor / destructor
        Controller(unsigned short port, std::string password, bool pretty);
@@ -0,0 +1,230 @@
+#include "h264_stream.h"
+
+#ifdef SPICE_H264
+
+#include <vector>
+
+#include <x264.h>
+
+#include "util/logging.h"
+
+namespace api {
+
+    namespace {
+
+        // BT.601 limited range, the range every decoder assumes for H.264 without
+        // explicit colour metadata
+        inline uint8_t rgb_to_y(int r, int g, int b) {
+            return static_cast<uint8_t>(((66 * r + 129 * g + 25 * b + 128) >> 8) + 16);
+        }
+
+        inline uint8_t rgb_to_u(int r, int g, int b) {
+            return static_cast<uint8_t>(((-38 * r - 74 * g + 112 * b + 128) >> 8) + 128);
+        }
+
+        inline uint8_t rgb_to_v(int r, int g, int b) {
+            return static_cast<uint8_t>(((112 * r - 94 * g - 18 * b + 128) >> 8) + 128);
+        }
+
+        // a bare annex-b elementary stream, one encoder per connection so every client
+        // starts on its own keyframe. no container, so nothing here keeps a media clock
+        class H264Writer : public StreamWriter {
+        public:
+
+            H264Writer(int quality, int fps) : quality(quality), fps(fps) {}
+
+            ~H264Writer() override {
+                this->close();
+            }
+
+            std::string content_type() const override {
+                return "video/h264";
+            }
+
+            bool write(const StreamSend &send, const capture_pump::Frame &frame) override {
+
+                // I420 needs even dimensions
+                const int width = frame.width & ~1;
+                const int height = frame.height & ~1;
+                if (width <= 0 || height <= 0) {
+                    return true;
+                }
+
+                if (this->encoder == nullptr) {
+                    if (!this->open(width, height)) {
+                        return false;
+                    }
+                } else if (width != this->width || height != this->height) {
+                    // the encoder is fixed at the size it opened with; let the client reconnect
+                    log_info("api::stream", "capture size changed, ending H.264 client");
+                    return false;
+                }
+
+                this->convert(frame.pixels.get(), frame.width);
+
+                this->picture.i_pts = this->frame_index;
+
+                x264_nal_t *nals = nullptr;
+                int nal_count = 0;
+                x264_picture_t picture_out;
+                const int size = x264_encoder_encode(
+                        this->encoder, &nals, &nal_count, &this->picture, &picture_out);
+
+                if (size < 0) {
+                    log_warning("api::stream", "H.264 encode failed");
+                    return false;
+                }
+
+                this->frame_index++;
+
+                if (size == 0) {
+                    return true;
+                }
+
+                // x264 lays every NAL of the frame out back to back. an SEI or delimiter
+                // carries no picture, so only the parameter sets and the slice go through
+                this->annexb.clear();
+                for (int i = 0; i < nal_count; i++) {
+                    switch (nals[i].i_type) {
+                        case NAL_SEI:
+                        case NAL_AUD:
+                        case NAL_FILLER:
+                            continue;
+                        default:
+                            break;
+                    }
+                    this->annexb.insert(this->annexb.end(),
+                            nals[i].p_payload, nals[i].p_payload + nals[i].i_payload);
+                }
+
+                if (this->annexb.empty()) {
+                    return true;
+                }
+
+                return send(this->annexb.data(), this->annexb.size());
+            }
+
+        private:
+
+            bool open(int width, int height) {
+
+                x264_param_t param;
+                if (x264_param_default_preset(&param, "ultrafast", "zerolatency") < 0) {
+                    return false;
+                }
+
+                param.i_csp = X264_CSP_I420;
+                param.i_width = width;
+                param.i_height = height;
+                param.i_fps_num = this->fps;
+                param.i_fps_den = 1;
+
+                // sliced threading, which zerolatency already selected, so a frame is split
+                // across workers rather than held back to be reordered. deliberately not the
+                // automatic count: this shares a machine with the game it is capturing, and
+                // taking every core to encode would win back frames at the game's expense
+                param.i_threads = 4;
+
+                param.b_annexb = 1;
+                // SPS/PPS ahead of every IDR, so a client can start decoding cold
+                param.b_repeat_headers = 1;
+                // a keyframe every two seconds bounds how long a new client waits
+                param.i_keyint_max = this->fps * 2;
+                param.i_log_level = X264_LOG_NONE;
+                param.rc.i_rc_method = X264_RC_CRF;
+                param.rc.f_rf_constant = 40.0f - (this->quality * 0.25f);
+
+                // baseline keeps hardware decode available on the widest range of phones
+                if (x264_param_apply_profile(&param, "baseline") < 0) {
+                    return false;
+                }
+
+                this->encoder = x264_encoder_open(&param);
+                if (this->encoder == nullptr) {
+                    log_warning("api::stream", "could not open the H.264 encoder");
+                    return false;
+                }
+
+                if (x264_picture_alloc(&this->picture, X264_CSP_I420, width, height) < 0) {
+                    this->close();
+                    return false;
+                }
+                this->picture_ready = true;
+
+                this->width = width;
+                this->height = height;
+                return true;
+            }
+
+            void close() {
+                if (this->picture_ready) {
+                    x264_picture_clean(&this->picture);
+                    this->picture_ready = false;
+                }
+                if (this->encoder != nullptr) {
+                    x264_encoder_close(this->encoder);
+                    this->encoder = nullptr;
+                }
+            }
+
+            // packed 24bpp RGB to I420, averaging each 2x2 block for the chroma planes
+            void convert(const uint8_t *rgb, int source_width) {
+
+                uint8_t *plane_y = this->picture.img.plane[0];
+                uint8_t *plane_u = this->picture.img.plane[1];
+                uint8_t *plane_v = this->picture.img.plane[2];
+                const int stride_y = this->picture.img.i_stride[0];
+                const int stride_u = this->picture.img.i_stride[1];
+                const int stride_v = this->picture.img.i_stride[2];
+
+                for (int y = 0; y < this->height; y++) {
+                    const uint8_t *row = rgb + static_cast<size_t>(y) * source_width * 3;
+                    uint8_t *out_y = plane_y + static_cast<size_t>(y) * stride_y;
+
+                    for (int x = 0; x < this->width; x++) {
+                        const uint8_t *pixel = row + x * 3;
+                        out_y[x] = rgb_to_y(pixel[0], pixel[1], pixel[2]);
+                    }
+                }
+
+                for (int y = 0; y < this->height / 2; y++) {
+                    const uint8_t *row0 = rgb + static_cast<size_t>(y * 2) * source_width * 3;
+                    const uint8_t *row1 = row0 + static_cast<size_t>(source_width) * 3;
+                    uint8_t *out_u = plane_u + static_cast<size_t>(y) * stride_u;
+                    uint8_t *out_v = plane_v + static_cast<size_t>(y) * stride_v;
+
+                    for (int x = 0; x < this->width / 2; x++) {
+                        const uint8_t *p00 = row0 + (x * 2) * 3;
+                        const uint8_t *p01 = p00 + 3;
+                        const uint8_t *p10 = row1 + (x * 2) * 3;
+                        const uint8_t *p11 = p10 + 3;
+
+                        const int r = (p00[0] + p01[0] + p10[0] + p11[0] + 2) / 4;
+                        const int g = (p00[1] + p01[1] + p10[1] + p11[1] + 2) / 4;
+                        const int b = (p00[2] + p01[2] + p10[2] + p11[2] + 2) / 4;
+
+                        out_u[x] = rgb_to_u(r, g, b);
+                        out_v[x] = rgb_to_v(r, g, b);
+                    }
+                }
+            }
+
+            int quality;
+            int fps;
+            int width = 0;
+            int height = 0;
+            int64_t frame_index = 0;
+            std::vector<uint8_t> annexb;
+
+            x264_t *encoder = nullptr;
+            x264_picture_t picture {};
+            bool picture_ready = false;
+        };
+    }
+
+    std::unique_ptr<StreamWriter> make_h264_writer(int quality, int fps) {
+        return std::make_unique<H264Writer>(quality, fps);
+    }
+}
+
+#endif // SPICE_H264
@@ -0,0 +1,11 @@
+#pragma once
+
+#include <memory>
+
+#include "stream_format.h"
+
+namespace api {
+
+    // bare annex-b H.264; null when the build has no encoder
+    std::unique_ptr<StreamWriter> make_h264_writer(int quality, int fps);
+}
@@ -16,6 +16,14 @@ namespace api {
        this->password_force = password_force;
    }

+    void Module::require_password(const std::string &function) {
+        this->password_force_functions.emplace(function);
+    }
+
+    bool Module::requires_password(const std::string &function) const {
+        return this->password_force || this->password_force_functions.contains(function);
+    }
+
    void Module::handle(Request &req, Response &res) {

        // log module access
@@ -4,6 +4,7 @@
 #include <map>
 #include <string>
 #include <sstream>
+#include <unordered_set>
 #include <external/robin_hood.h>

 #include "response.h"
@@ -26,6 +27,13 @@ namespace api {
        // default constructor
        explicit Module(std::string name, bool password_force=false);

+        void require_password(const std::string &function);
+
+    private:
+
+        // functions which expose sensitive data or actions
+        std::unordered_set<std::string> password_force_functions;
+
    public:

        // virtual deconstructor
@@ -35,6 +43,8 @@ namespace api {
        std::string name;
        bool password_force;

+        bool requires_password(const std::string &function) const;
+
        // the magic
        void handle(Request &req, Response &res);

@@ -1,9 +1,14 @@
 #include "capture.h"
+#include <atomic>
 #include <functional>
 #include <mutex>
 #include <unordered_map>
+#include "api/capture_pump.h"
+#include "api/stream_format.h"
+#include "api/stream_server.h"
 #include "external/rapidjson/document.h"
 #include "hooks/graphics/graphics.h"
+#include "hooks/graphics/jpeg_encoder.h"
 #include "util/crypt.h"

 using namespace std::placeholders;
@@ -69,6 +74,7 @@ namespace api::modules {
    Capture::Capture() : Module("capture") {
        functions["get_screens"] = std::bind(&Capture::get_screens, this, _1, _2);
        functions["get_jpg"] = std::bind(&Capture::get_jpg, this, _1, _2);
+        functions["get_streams"] = std::bind(&Capture::get_streams, this, _1, _2);
    }

    /**
@@ -118,9 +124,16 @@ namespace api::modules {
        uint64_t timestamp = 0;
        int width = 0;
        int height = 0;
-        graphics_capture_trigger(screen);
-        bool success = graphics_capture_receive_jpeg(
-                screen, CAPTURE_BUFFER, quality, divide, &timestamp, &width, &height);
+
+        std::shared_ptr<uint8_t[]> pixels;
+        bool success = capture_pump::capture_direct(
+                screen, pixels, divide, &timestamp, &width, &height);
+
+        if (success) {
+            CAPTURE_BUFFER.clear();
+            success = jpeg_encoder::encode(
+                    CAPTURE_BUFFER, pixels.get(), width, height, quality);
+        }

        if (success) {
            add_jpeg_response(screen, timestamp, width, height, CAPTURE_BUFFER, res);
@@ -132,4 +145,98 @@ namespace api::modules {
        CAPTURE_BUFFER.clear();
        try_cached_response(screen, res);
    }
+
+    /**
+     * get_streams()
+     */
+    void Capture::get_streams(Request &req, Response &res) {
+
+        auto &alloc = res.doc()->GetAllocator();
+
+        // nothing is listening without -apistream, so there is no stream to describe
+        const unsigned short port = stream_server_port();
+        if (port == 0) {
+            return;
+        }
+
+        Value formats(kArrayType);
+        for (const auto &[name, path] : stream_formats()) {
+            Value entry(kObjectType);
+            entry.AddMember("name", Value(name.c_str(), alloc), alloc);
+            entry.AddMember("path", Value(path.c_str(), alloc), alloc);
+            formats.PushBack(entry, alloc);
+        }
+
+        std::vector<int> screen_numbers;
+        graphics_screens_get(screen_numbers);
+
+        // measuring a screen nobody has captured yet waits for the game to present, which can
+        // take as long as the whole request is allowed, so only one screen is measured per
+        // call and the rest are reported null until a later one settles them. which screen
+        // gets the attempt rotates, otherwise one that never presents would take every
+        // request and the screens behind it would stay unmeasured forever
+        int probe_screen = -1;
+        {
+            std::vector<int> unmeasured;
+            for (const auto screen : screen_numbers) {
+                if (screen < static_cast<int>(GRAPHICS_CAPTURE_SCREEN_NO)
+                        && !graphics_capture_last_size(screen, nullptr, nullptr)
+                        && !capture_pump::screen_claimed(screen)) {
+                    unmeasured.push_back(screen);
+                }
+            }
+
+            if (!unmeasured.empty()) {
+                static std::atomic<unsigned> probe_cursor { 0 };
+                probe_screen = unmeasured[probe_cursor.fetch_add(1) % unmeasured.size()];
+            }
+        }
+
+        Value screens(kArrayType);
+        for (const auto screen : screen_numbers) {
+            if (screen >= static_cast<int>(GRAPHICS_CAPTURE_SCREEN_NO)) {
+                continue;
+            }
+
+            int width = 0;
+            int height = 0;
+            bool known = graphics_capture_last_size(screen, &width, &height);
+
+            // a probe holds the screen for as long as it waits, so a second caller arriving
+            // during one would queue behind it and then take a wait of its own; let it report
+            // the screen as unmeasured instead and pick the size up once the first is done
+            static std::atomic<bool> probe_running { false };
+            if (!known && screen == probe_screen && !probe_running.exchange(true)) {
+                std::shared_ptr<uint8_t[]> pixels;
+                known = capture_pump::capture_direct(
+                        screen, pixels, 1, nullptr, &width, &height);
+                probe_running = false;
+            }
+
+            // a screen of unknown size cannot be described, and a client told about it could
+            // not size its decoder anyway; leaving it out until it has been measured beats
+            // handing over an entry that has to be treated as absent
+            if (!known) {
+                continue;
+            }
+
+            Value entry(kObjectType);
+            entry.AddMember("screen", screen, alloc);
+            entry.AddMember("width", width, alloc);
+            entry.AddMember("height", height, alloc);
+
+            // a screen carries one viewer at a time, so this is what decides whether a client
+            // can connect at all; still racy by the time it does, only more honest than not
+            entry.AddMember("busy", capture_pump::screen_claimed(screen), alloc);
+
+            screens.PushBack(entry, alloc);
+        }
+
+        Value info(kObjectType);
+        info.AddMember("port", port, alloc);
+        info.AddMember("formats", formats, alloc);
+        info.AddMember("screens", screens, alloc);
+
+        res.add_data(info);
+    }
 }
@@ -19,5 +19,6 @@ namespace api::modules {
        // function definitions
        void get_screens(Request &req, Response &res);
        void get_jpg(Request &req, Response &res);
+        void get_streams(Request &req, Response &res);
    };
 }
@@ -1,4 +1,5 @@
 #include "card.h"
+#include <fstream>
 #include <functional>
 #include "external/rapidjson/document.h"
 #include "util/logging.h"
@@ -11,8 +12,71 @@ using namespace rapidjson;

 namespace api::modules {

+    static bool normalize_card_id(const std::string &value, std::string &card_id) {
+        if (value.size() != 16) {
+            return false;
+        }
+
+        uint8_t card_bin[8] {};
+        if (!hex2bin(value.c_str(), card_bin)) {
+            return false;
+        }
+
+        card_id = bin2hex(card_bin, std::size(card_bin));
+        return true;
+    }
+
+    static bool read_card_id(const std::filesystem::path &path, std::string &card_id) {
+        std::ifstream file(path);
+        char buffer[16] {};
+        if (!file.read(buffer, std::size(buffer))) {
+            return false;
+        }
+
+        return normalize_card_id(std::string(buffer, std::size(buffer)), card_id);
+    }
+
    Card::Card() : Module("card") {
+        functions["get_cards"] = std::bind(&Card::get_cards, this, _1, _2);
        functions["insert"] = std::bind(&Card::insert, this, _1, _2);
+        require_password("get_cards");
+    }
+
+    /**
+     * get_cards()
+     */
+    void Card::get_cards(Request &req, Response &res) {
+        auto &alloc = res.doc()->GetAllocator();
+
+        for (int index = 0; index < eamuse_get_game_keypads(); index++) {
+            std::string card_id;
+            std::string filename;
+            const auto card_override = eamuse_get_card_override(index);
+            const bool has_override = !card_override.empty();
+
+            if (has_override) {
+                if (!normalize_card_id(card_override, card_id)) {
+                    continue;
+                }
+            } else {
+                const auto path = eamuse_get_card_path(index);
+                if (!read_card_id(path, card_id)) {
+                    continue;
+                }
+
+                const auto filename_u8 = path.filename().u8string();
+                filename.assign(filename_u8.begin(), filename_u8.end());
+            }
+
+            Value card(kObjectType);
+            card.AddMember("index", index, alloc);
+            card.AddMember("card_id", Value(card_id.c_str(), alloc), alloc);
+            card.AddMember("source", Value(has_override ? "override" : "file", alloc), alloc);
+            if (!has_override) {
+                card.AddMember("file_name", Value(filename.c_str(), alloc), alloc);
+            }
+            res.add_data(card);
+        }
    }

    /**
@@ -12,6 +12,7 @@ namespace api::modules {
    private:

        // function definitions
+        void get_cards(Request &req, Response &res);
        void insert(Request &req, Response &res);
    };
 }
@@ -61,7 +61,7 @@ namespace api::modules {
            return error_type(res, "amount", "int");

        // add to coin stock
-        eamuse_coin_set_stock(eamuse_coin_get_stock() + std::max(0, req.params[0].GetInt()));
+        eamuse_coin_add(std::max(0, req.params[0].GetInt()));
    }

    /*
@@ -11,6 +11,7 @@ part "src/exceptions.dart";
 part "src/rc4.dart";
 part "src/wrappers/analogs.dart";
 part "src/wrappers/buttons.dart";
+part "src/wrappers/capture.dart";
 part "src/wrappers/card.dart";
 part "src/wrappers/coin.dart";
 part "src/wrappers/control.dart";
@@ -4,8 +4,8 @@ part of spiceapi;
 class Connection {

  // settings
-  static const _TIMEOUT = Duration(seconds: 2);
-  static const _BUFFER_SIZE = 1024 * 8;
+  static const _TIMEOUT = Duration(seconds: 3);
+  static const _BUFFER_SIZE = 1024 * 1024 * 8;

  // state
  final String host, pass;
@@ -0,0 +1,47 @@
+part of spiceapi;
+
+class CaptureData {
+  int timestamp;
+  int width, height;
+  Uint8List data;
+}
+
+var _base64DecoderInstance = Base64Decoder();
+
+Future<List> captureGetScreens(Connection con) {
+  var req = Request("capture", "get_screens");
+  return con.request(req).then((res) {
+    return res.getData();
+  });
+}
+
+Future<CaptureData> captureGetJPG(Connection con, {
+  int screen = 0,
+  int quality = 70,
+  int divide = 1,
+}) {
+  var req = Request("capture", "get_jpg");
+  req.addParam(screen);
+  req.addParam(quality);
+  req.addParam(divide);
+  return con.request(req).then((res) {
+    var captureData = CaptureData();
+    var data = res.getData();
+    if (data.length > 0) captureData.timestamp = data[0];
+    if (data.length > 1) captureData.width = data[1];
+    if (data.length > 2) captureData.height = data[2];
+    if (data.length > 3) {
+      captureData.data = _base64DecoderInstance.convert(data[3]);
+    }
+    return captureData;
+  });
+}
+
+/// Describes the HTTP video stream, or null when this spice2x serves none.
+Future<Map> captureGetStreams(Connection con) {
+  var req = Request("capture", "get_streams");
+  return con.request(req).then((res) {
+    var data = res.getData();
+    return data.length > 0 ? data[0] : null;
+  });
+}
@@ -1,5 +1,32 @@
 part of spiceapi;

+class CardInfo {
+  final int index;
+  final String cardID;
+  final String source;
+  final String? fileName;
+
+  CardInfo(this.index, this.cardID, this.source, this.fileName);
+}
+
+Future<List<CardInfo>> cardGetCards(Connection con) {
+  var req = Request("card", "get_cards");
+  return con.request(req).then((res) {
+    List<CardInfo> cards = [];
+    for (var value in res.getData()) {
+      cards.add(
+        CardInfo(
+          value["index"],
+          value["card_id"],
+          value["source"],
+          value["file_name"],
+        ),
+      );
+    }
+    return cards;
+  });
+}
+
 Future<void> cardInsert(Connection con, int unit, String cardID) {
  var req = Request("card", "insert");
  req.addParam(unit);
@@ -17,7 +17,7 @@ Future<List> captureGetScreens(Connection con) {

 Future<CaptureData> captureGetJPG(Connection con, {
  int screen = 0,
-  int quality = 60,
+  int quality = 70,
  int divide = 1,
 }) {
  var req = Request("capture", "get_jpg");
@@ -36,3 +36,12 @@ Future<CaptureData> captureGetJPG(Connection con, {
    return captureData;
  });
 }
+
+/// Describes the HTTP video stream, or null when this spice2x serves none.
+Future<Map> captureGetStreams(Connection con) {
+  var req = Request("capture", "get_streams");
+  return con.request(req).then((res) {
+    var data = res.getData();
+    return data.length > 0 ? data[0] : null;
+  });
+}
@@ -1,5 +1,32 @@
 part of spiceapi;

+class CardInfo {
+  final int index;
+  final String cardID;
+  final String source;
+  final String? fileName;
+
+  CardInfo(this.index, this.cardID, this.source, this.fileName);
+}
+
+Future<List<CardInfo>> cardGetCards(Connection con) {
+  var req = Request("card", "get_cards");
+  return con.request(req).then((res) {
+    List<CardInfo> cards = [];
+    for (var value in res.getData()) {
+      cards.add(
+        CardInfo(
+          value["index"],
+          value["card_id"],
+          value["source"],
+          value["file_name"],
+        ),
+      );
+    }
+    return cards;
+  });
+}
+
 Future<void> cardInsert(Connection con, int unit, String cardID) {
  var req = Request("card", "insert");
  req.addParam(unit);
@@ -2,6 +2,7 @@ from .connection import Connection
 from .request import Request
 from .analogs import *
 from .buttons import *
+from .capture import *
 from .card import *
 from .coin import *
 from .control import *
@@ -0,0 +1,33 @@
+import base64
+
+from .connection import Connection
+from .request import Request
+
+
+def capture_get_screens(con: Connection):
+    res = con.request(Request("capture", "get_screens"))
+    return res.get_data()
+
+
+def capture_get_jpg(con: Connection, screen: int = 0, quality: int = 70, divide: int = 1):
+    req = Request("capture", "get_jpg")
+    req.add_param(screen)
+    req.add_param(quality)
+    req.add_param(divide)
+    data = con.request(req).get_data()
+
+    if len(data) < 4:
+        return None
+
+    return {
+        "timestamp": data[0],
+        "width": data[1],
+        "height": data[2],
+        "data": base64.b64decode(data[3]),
+    }
+
+
+def capture_get_streams(con: Connection):
+    """Describes the HTTP video stream, or None when this spice2x serves none."""
+    data = con.request(Request("capture", "get_streams")).get_data()
+    return data[0] if data else None
@@ -2,6 +2,10 @@ from .connection import Connection
 from .request import Request


+def card_get_cards(con: Connection):
+    return con.request(Request("card", "get_cards")).get_data()
+
+
 def card_insert(con: Connection, unit: int, card_id: str):
    req = Request("card", "insert")
    req.add_param(unit)
@@ -0,0 +1,84 @@
+#include "stream_format.h"
+
+#include <vector>
+
+#include "h264_stream.h"
+#include "hooks/graphics/jpeg_encoder.h"
+
+namespace api {
+
+    namespace {
+
+#ifdef SPICE_JPEG
+        constexpr const char *MJPEG_BOUNDARY = "spice2xframe";
+
+        // multipart/x-mixed-replace: every frame is a standalone JPEG, no inter-frame state
+        class MjpegWriter : public StreamWriter {
+        public:
+
+            explicit MjpegWriter(int quality) : quality(quality) {}
+
+            std::string content_type() const override {
+                return std::string("multipart/x-mixed-replace; boundary=") + MJPEG_BOUNDARY;
+            }
+
+            bool write(const StreamSend &send, const capture_pump::Frame &frame) override {
+                this->jpeg.clear();
+                if (!jpeg_encoder::encode(
+                        this->jpeg, frame.pixels.get(),
+                        frame.width, frame.height, this->quality)) {
+                    // a frame the encoder rejects is not worth dropping the client over
+                    return true;
+                }
+
+                const std::string part =
+                        "--" + std::string(MJPEG_BOUNDARY) + "\r\n"
+                        "Content-Type: image/jpeg\r\n"
+                        "Content-Length: " + std::to_string(this->jpeg.size()) + "\r\n"
+                        "\r\n";
+
+                return send(part.data(), part.size())
+                        && send(this->jpeg.data(), this->jpeg.size())
+                        && send("\r\n", 2);
+            }
+
+        private:
+            int quality;
+            std::vector<uint8_t> jpeg;
+        };
+#endif
+    }
+
+    // both parameters go unused on toolchains that compile in neither format
+    std::unique_ptr<StreamWriter> make_stream_writer(
+            const std::string &path, [[maybe_unused]] int quality, [[maybe_unused]] int fps) {
+
+#ifdef SPICE_JPEG
+        if (path == "/stream.mjpg") {
+            return std::make_unique<MjpegWriter>(quality);
+        }
+#endif
+
+#ifdef SPICE_H264
+        if (path == "/stream.h264") {
+            return make_h264_writer(quality, fps);
+        }
+#endif
+
+        return nullptr;
+    }
+
+    std::vector<std::pair<std::string, std::string>> stream_formats() {
+        std::vector<std::pair<std::string, std::string>> formats;
+
+#ifdef SPICE_JPEG
+        formats.emplace_back("mjpeg", "/stream.mjpg");
+#endif
+
+#ifdef SPICE_H264
+        formats.emplace_back("h264", "/stream.h264");
+#endif
+
+        return formats;
+    }
+}
@@ -0,0 +1,43 @@
+#pragma once
+
+#include <cstddef>
+#include <functional>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "capture_pump.h"
+
+namespace api {
+
+    // writes bytes to the client; false once the connection is gone
+    using StreamSend = std::function<bool(const void *, size_t)>;
+
+    // one wire format, instantiated per connection so it can keep encoder state across frames
+    class StreamWriter {
+    public:
+        virtual ~StreamWriter() = default;
+
+        StreamWriter(const StreamWriter &) = delete;
+        StreamWriter &operator=(const StreamWriter &) = delete;
+
+        // value for the HTTP Content-Type response header
+        virtual std::string content_type() const = 0;
+
+        // for formats that open with an init segment; runs once before any frame
+        virtual bool begin(const StreamSend &send) { return true; }
+
+        virtual bool write(const StreamSend &send, const capture_pump::Frame &frame) = 0;
+
+    protected:
+        StreamWriter() = default;
+    };
+
+    // null when the path does not name a format this build supports
+    std::unique_ptr<StreamWriter> make_stream_writer(
+            const std::string &path, int quality, int fps);
+
+    // name and path of every format compiled into this build, for clients to pick from
+    std::vector<std::pair<std::string, std::string>> stream_formats();
+}
@@ -0,0 +1,525 @@
+#include <winsock2.h>
+#include <ws2tcpip.h>
+
+#include "stream_server.h"
+
+#include <algorithm>
+#include <cctype>
+#include <chrono>
+#include <limits>
+#include <map>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include "capture_pump.h"
+#include "hooks/graphics/graphics.h"
+#include "overlay/notifications.h"
+#include "stream_format.h"
+#include "util/logging.h"
+#include "util/utils.h"
+
+namespace api {
+
+    namespace {
+
+        struct HttpRequest {
+            std::string method;
+            std::string path;
+            std::map<std::string, std::string> query;
+        };
+
+        bool send_all(SOCKET socket, const void *data, size_t size) {
+            auto cursor = reinterpret_cast<const char *>(data);
+            size_t remaining = size;
+
+            while (remaining > 0) {
+                const int sent = send(socket, cursor, static_cast<int>(remaining), 0);
+                if (sent <= 0) {
+                    return false;
+                }
+                cursor += sent;
+                remaining -= static_cast<size_t>(sent);
+            }
+
+            return true;
+        }
+
+        bool send_all(SOCKET socket, const std::string &text) {
+            return send_all(socket, text.data(), text.size());
+        }
+
+        // a viewer leaving is normally noticed by a failing send, so a stream with no frame
+        // to push has to ask the socket instead
+        bool client_gone(SOCKET socket) {
+            fd_set read_set;
+            FD_ZERO(&read_set);
+            FD_SET(socket, &read_set);
+
+            // the socket is blocking with a receive timeout, so poll before touching it
+            timeval immediately {};
+            const int ready = select(0, &read_set, nullptr, nullptr, &immediately);
+            if (ready == 0) {
+                return false;
+            }
+            if (ready < 0) {
+                return true;
+            }
+
+            // consumed rather than peeked: a stray byte would otherwise sit in front of the
+            // FIN and keep hiding it for as long as the stream runs
+            char discard[256];
+            return recv(socket, discard, sizeof(discard), 0) <= 0;
+        }
+
+        std::string url_decode(const std::string &input) {
+            std::string out;
+            out.reserve(input.size());
+
+            for (size_t i = 0; i < input.size(); i++) {
+                if (input[i] == '+') {
+                    out.push_back(' ');
+                } else if (input[i] == '%' && i + 2 < input.size()
+                        && isxdigit(static_cast<unsigned char>(input[i + 1]))
+                        && isxdigit(static_cast<unsigned char>(input[i + 2]))) {
+                    out.push_back(static_cast<char>(
+                            std::stoi(input.substr(i + 1, 2), nullptr, 16)));
+                    i += 2;
+                } else {
+                    out.push_back(input[i]);
+                }
+            }
+
+            return out;
+        }
+
+        void parse_query(const std::string &query, HttpRequest &request) {
+            size_t pos = 0;
+
+            while (pos < query.size()) {
+                auto end = query.find('&', pos);
+                if (end == std::string::npos) {
+                    end = query.size();
+                }
+
+                const auto pair = query.substr(pos, end - pos);
+                const auto split = pair.find('=');
+                if (split != std::string::npos && split > 0) {
+                    request.query[url_decode(pair.substr(0, split))] =
+                            url_decode(pair.substr(split + 1));
+                }
+
+                pos = end + 1;
+            }
+        }
+
+        // reads the request head only; anything oversized or malformed is refused
+        bool read_request(SOCKET socket, size_t size_limit, HttpRequest &request) {
+            std::string head;
+            char buffer[1024];
+
+            while (head.find("\r\n\r\n") == std::string::npos) {
+                if (head.size() >= size_limit) {
+                    return false;
+                }
+
+                // read no further than the limit, so the head cannot overshoot it
+                const size_t budget = std::min(sizeof(buffer), size_limit - head.size());
+                const int received = recv(socket, buffer, static_cast<int>(budget), 0);
+                if (received <= 0) {
+                    return false;
+                }
+
+                head.append(buffer, static_cast<size_t>(received));
+            }
+
+            const auto line_end = head.find("\r\n");
+            const auto line = head.substr(0, line_end);
+
+            const auto method_end = line.find(' ');
+            if (method_end == std::string::npos) {
+                return false;
+            }
+
+            const auto target_end = line.find(' ', method_end + 1);
+            if (target_end == std::string::npos) {
+                return false;
+            }
+
+            request.method = line.substr(0, method_end);
+            auto target = line.substr(method_end + 1, target_end - method_end - 1);
+
+            const auto query_start = target.find('?');
+            if (query_start != std::string::npos) {
+                parse_query(target.substr(query_start + 1), request);
+                target = target.substr(0, query_start);
+            }
+
+            request.path = url_decode(target);
+            return true;
+        }
+
+        int query_int(const HttpRequest &request, const std::string &name, int fallback,
+                int min, int max) {
+
+            const auto pos = request.query.find(name);
+            if (pos == request.query.end()) {
+                return fallback;
+            }
+
+            try {
+                return std::clamp(std::stoi(pos->second), min, max);
+            } catch (const std::exception &) {
+                return fallback;
+            }
+        }
+
+        // an <img> can show a cross-origin stream without this, but a browser client that
+        // decodes the bytes itself has to fetch() them, and fetch is subject to CORS. errors
+        // carry it too, or the client sees an opaque failure instead of the status.
+        constexpr const char *cors_header = "Access-Control-Allow-Origin: *\r\n";
+
+        // the port is unauthenticated, so a scanner hammering a busy/missing screen could
+        // otherwise flood the overlay; throttle failure toasts per distinct cause. kept under
+        // a second so it only swallows that, not a legitimate reconnect - substream itself
+        // switches screens with a 300ms gap, and only backs off to a full second once a
+        // retry has actually failed
+        constexpr double notification_throttle_seconds = 0.5;
+
+        void send_error(SOCKET socket, const char *status) {
+            const std::string response =
+                    std::string("HTTP/1.0 ") + status + "\r\n"
+                    + cors_header +
+                    "Content-Length: 0\r\n"
+                    "Connection: close\r\n"
+                    "\r\n";
+            send_all(socket, response);
+        }
+
+        std::atomic<unsigned short> LISTENING_PORT { 0 };
+    }
+
+    unsigned short stream_server_port() {
+        return LISTENING_PORT.load();
+    }
+
+    StreamServer::StreamServer(unsigned short port)
+        : port(port)
+    {
+        // WinXP builds compile in neither encoder, so there would be nothing to serve and
+        // every request would 404; taking the port instead only invites confused clients
+        if (stream_formats().empty()) {
+            log_warning("api::stream",
+                    "this build has no video encoders, the video stream is unavailable");
+            return;
+        }
+
+        if (!this->open_listener()) {
+            // the stream was asked for explicitly, so say plainly that it is not there
+            log_warning("api::stream",
+                    "the video stream is not available on port {}", this->port);
+            return;
+        }
+
+        this->running = true;
+        this->acceptor = std::thread([this] {
+            this->accept_worker();
+        });
+
+        LISTENING_PORT = this->port;
+
+        // deliberately not logging a full URL; local IPs would leak into shared logs
+        log_info("api::stream", "video stream is listening on port: {}", this->port);
+        log_warning("api::stream",
+                "the video stream is unauthenticated - anyone who can reach port {} can watch "
+                "the game screen", this->port);
+    }
+
+    bool StreamServer::open_listener() {
+        WSADATA wsa_data;
+        const int error = WSAStartup(MAKEWORD(2, 2), &wsa_data);
+        if (error != 0) {
+            log_warning("api::stream", "WSAStartup() returned {}", error);
+            return false;
+        }
+        this->wsa_started = true;
+
+        this->listener = socket(AF_INET, SOCK_STREAM, 0);
+        if (this->listener == INVALID_SOCKET) {
+            log_warning("api::stream", "could not create listener socket: {}",
+                    get_last_error_string());
+            return false;
+        }
+
+        int opt_enable = 1;
+        if (setsockopt(this->listener, SOL_SOCKET, SO_REUSEADDR,
+                reinterpret_cast<const char *>(&opt_enable), sizeof(int)) == -1) {
+            log_warning("api::stream", "could not set socket option SO_REUSEADDR: {}",
+                    get_last_error_string());
+        }
+
+        sockaddr_in server_address {};
+        server_address.sin_family = AF_INET;
+        server_address.sin_port = htons(this->port);
+        server_address.sin_addr.s_addr = INADDR_ANY;
+
+        if (bind(this->listener, (sockaddr *) &server_address, sizeof(sockaddr)) == -1) {
+            log_warning("api::stream", "could not bind socket on port {}: {}",
+                    this->port, get_last_error_string());
+            closesocket(this->listener);
+            this->listener = INVALID_SOCKET;
+            return false;
+        }
+
+        if (listen(this->listener, server_backlog) == -1) {
+            log_warning("api::stream", "could not listen on port {}: {}",
+                    this->port, get_last_error_string());
+            closesocket(this->listener);
+            this->listener = INVALID_SOCKET;
+            return false;
+        }
+
+        return true;
+    }
+
+    StreamServer::~StreamServer() {
+
+        this->running = false;
+        LISTENING_PORT = 0;
+
+        if (this->listener != INVALID_SOCKET) {
+            closesocket(this->listener);
+            this->listener = INVALID_SOCKET;
+        }
+
+        // drops the client threads out of their blocking send/recv
+        {
+            std::lock_guard<std::mutex> lock(this->clients_m);
+            for (auto &client : this->clients) {
+                if (client.socket != INVALID_SOCKET) {
+                    ::shutdown(client.socket, SD_BOTH);
+                }
+            }
+        }
+
+        if (this->acceptor.joinable()) {
+            this->acceptor.join();
+        }
+
+        // joining is what guarantees no client thread outlives this object
+        for (auto &client : this->clients) {
+            if (client.thread.joinable()) {
+                client.thread.join();
+            }
+        }
+
+        if (this->wsa_started) {
+            WSACleanup();
+        }
+    }
+
+    void StreamServer::accept_worker() {
+
+        while (this->running) {
+            sockaddr_in client_address {};
+            int client_address_size = sizeof(sockaddr_in);
+
+            const SOCKET client = accept(
+                    this->listener, (sockaddr *) &client_address, &client_address_size);
+            if (client == INVALID_SOCKET) {
+                // on shutdown the listener is closed under us; otherwise do not spin
+                if (this->running) {
+                    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+                }
+                continue;
+            }
+
+            if (!this->running) {
+                closesocket(client);
+                break;
+            }
+
+            char address_data[INET_ADDRSTRLEN] {};
+            inet_ntop(AF_INET, &client_address.sin_addr, address_data, INET_ADDRSTRLEN);
+            std::string address(address_data);
+
+            // every client costs an encode and real bandwidth, so the cap protects the game
+            int slot = -1;
+            {
+                std::lock_guard<std::mutex> lock(this->clients_m);
+                for (size_t i = 0; i < this->clients.size(); i++) {
+                    if (!this->clients[i].active) {
+                        this->clients[i].active = true;
+                        this->clients[i].socket = client;
+                        slot = static_cast<int>(i);
+                        break;
+                    }
+                }
+            }
+
+            if (slot < 0) {
+                log_warning("api::stream", "client limit of {} hit", client_limit);
+                overlay::notifications::add_throttled(
+                        overlay::notifications::Severity::Warning,
+                        "api::stream.client_limit",
+                        notification_throttle_seconds,
+                        fmt::format("Video stream refused: client limit reached ({})", address));
+                send_error(client, "503 Service Unavailable");
+                closesocket(client);
+                continue;
+            }
+
+            // this thread is the only one that touches the thread objects, so the slot's
+            // previous occupant gets reaped here rather than being detached
+            if (this->clients[slot].thread.joinable()) {
+                this->clients[slot].thread.join();
+            }
+
+            this->clients[slot].thread = std::thread([this, slot, client, address] {
+                this->client_worker(slot, client, address);
+            });
+        }
+    }
+
+    void StreamServer::client_worker(int slot, SOCKET socket, std::string address) {
+
+        DWORD timeout = request_timeout_ms;
+        setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO,
+                reinterpret_cast<const char *>(&timeout), sizeof(timeout));
+
+        timeout = send_timeout_ms;
+        setsockopt(socket, SOL_SOCKET, SO_SNDTIMEO,
+                reinterpret_cast<const char *>(&timeout), sizeof(timeout));
+
+        int opt_enable = 1;
+        setsockopt(socket, IPPROTO_TCP, TCP_NODELAY,
+                reinterpret_cast<const char *>(&opt_enable), sizeof(int));
+
+        // whatever sits in the send buffer is already stale, and the default holds about a
+        // third of a second of H.264 because the bitrate is so low. keeping it small makes a
+        // slow reader block the sender, which then skips to the newest frame instead of
+        // handing over a backlog
+        int send_buffer = send_buffer_bytes;
+        setsockopt(socket, SOL_SOCKET, SO_SNDBUF,
+                reinterpret_cast<const char *>(&send_buffer), sizeof(send_buffer));
+
+        HttpRequest request;
+        if (read_request(socket, request_size_limit, request)) {
+            if (request.method != "GET") {
+                send_error(socket, "405 Method Not Allowed");
+            } else {
+                const int fps = query_int(request, "fps", 30, 1, fps_limit);
+                const int quality = query_int(request, "q", 70, 1, 100);
+
+                auto writer = make_stream_writer(request.path, quality, fps);
+                if (!writer) {
+                    send_error(socket, "404 Not Found");
+                } else {
+                    std::vector<int> screens;
+                    graphics_screens_get(screens);
+
+                    // registration takes a raw swapchain index and never bounds it, so the
+                    // capture range has to be enforced here rather than assumed
+                    const auto streamable = [&screens](int screen) {
+                        return screen < static_cast<int>(GRAPHICS_CAPTURE_SCREEN_NO)
+                                && std::find(screens.begin(), screens.end(), screen)
+                                        != screens.end();
+                    };
+
+                    // screen 1 is the subscreen in every game that has one; single-screen games
+                    // only ever register screen 0, so resolve the default against what exists.
+                    // left unclamped so a nonsense screen is reported as what was asked for
+                    int screen = query_int(request, "screen", -1, 0,
+                            std::numeric_limits<int>::max());
+                    if (screen < 0) {
+                        screen = streamable(1) ? 1 : 0;
+                    }
+
+                    // the default always lands on a screen that exists, so this is only ever
+                    // an explicit request for one that cannot be captured
+                    if (!streamable(screen)) {
+                        log_warning("api::stream",
+                                "screen {} is not available, refusing {}", screen, address);
+                        overlay::notifications::add_throttled(
+                                overlay::notifications::Severity::Warning,
+                                fmt::format("api::stream.screen_unavailable.{}", screen),
+                                notification_throttle_seconds,
+                                fmt::format("Video stream refused: screen {} not available ({})",
+                                        screen, address));
+                        send_error(socket, "404 Not Found");
+                    } else if (!capture_pump::claim_screen(screen)) {
+                        log_warning("api::stream",
+                                "screen {} is already being streamed, refusing {}",
+                                screen, address);
+                        overlay::notifications::add_throttled(
+                                overlay::notifications::Severity::Warning,
+                                fmt::format("api::stream.screen_claimed.{}", screen),
+                                notification_throttle_seconds,
+                                fmt::format("Video stream refused: screen {} already streaming ({})",
+                                        screen, address));
+                        send_error(socket, "503 Service Unavailable");
+                    } else {
+                        log_info("api::stream",
+                                "client connected: {} ({}, screen={}, fps={}, quality={})",
+                                address, request.path, screen, fps, quality);
+                        overlay::notifications::add(
+                                overlay::notifications::Severity::Success,
+                                fmt::format("Video stream client connected ({}, screen {})",
+                                        address, screen));
+
+                        const std::string header =
+                                "HTTP/1.0 200 OK\r\n"
+                                "Connection: close\r\n"
+                                + std::string(cors_header) +
+                                "Cache-Control: no-store, no-cache, must-revalidate\r\n"
+                                "Pragma: no-cache\r\n"
+                                "Content-Type: " + writer->content_type() + "\r\n"
+                                "\r\n";
+
+                        const StreamSend stream_send = [socket](const void *data, size_t size) {
+                            return send_all(socket, data, size);
+                        };
+
+                        if (send_all(socket, header) && writer->begin(stream_send)) {
+                            const auto interval = std::chrono::microseconds(1000000 / fps);
+
+                            while (this->running) {
+                                const auto started = std::chrono::steady_clock::now();
+
+                                capture_pump::Frame frame;
+                                const bool ok = capture_pump::capture_direct(
+                                        screen, frame.pixels, 1,
+                                        &frame.timestamp, &frame.width, &frame.height);
+
+                                if (ok && frame.pixels) {
+                                    if (!writer->write(stream_send, frame)) {
+                                        break;
+                                    }
+                                } else if (client_gone(socket)) {
+                                    break;
+                                }
+
+                                // a failed capture still paces, or a stalled game spins this
+                                std::this_thread::sleep_until(started + interval);
+                            }
+                        }
+
+                        capture_pump::release_screen(screen);
+                        log_info("api::stream", "client disconnected: {}", address);
+                        overlay::notifications::add(
+                                overlay::notifications::Severity::Info,
+                                fmt::format("Video stream client disconnected ({})", address));
+                    }
+                }
+            }
+        }
+
+        {
+            std::lock_guard<std::mutex> lock(this->clients_m);
+            this->clients[slot].socket = INVALID_SOCKET;
+            this->clients[slot].active = false;
+        }
+
+        closesocket(socket);
+    }
+}
@@ -0,0 +1,57 @@
+#pragma once
+
+#include <array>
+#include <atomic>
+#include <cstdint>
+#include <mutex>
+#include <string>
+#include <thread>
+
+#include <winsock2.h>
+
+namespace api {
+
+    // 0 while no stream server is listening, so the API can tell clients not to look for one
+    unsigned short stream_server_port();
+
+    class StreamServer {
+    public:
+
+        explicit StreamServer(unsigned short port);
+        ~StreamServer();
+
+        StreamServer(const StreamServer &) = delete;
+        StreamServer &operator=(const StreamServer &) = delete;
+
+    private:
+
+        // configuration
+        static constexpr int server_backlog = 4;
+        static constexpr int client_limit = 4;
+        static constexpr int request_size_limit = 8 * 1024;
+        static constexpr int request_timeout_ms = 5000;
+        static constexpr int send_timeout_ms = 5000;
+        // small enough that a low bitrate stream cannot hide a backlog of stale frames in it
+        static constexpr int send_buffer_bytes = 16 * 1024;
+        static constexpr int fps_limit = 60;
+
+        struct Client {
+            std::thread thread;
+            SOCKET socket = INVALID_SOCKET;
+            bool active = false;
+        };
+
+        void accept_worker();
+        bool open_listener();
+        void client_worker(int slot, SOCKET socket, std::string address);
+
+        unsigned short port;
+        SOCKET listener = INVALID_SOCKET;
+        bool wsa_started = false;
+        std::atomic_bool running { false };
+        std::thread acceptor;
+        std::mutex clients_m;
+        // socket and active are guarded by clients_m; only the acceptor touches thread
+        std::array<Client, client_limit> clients;
+    };
+}
@@ -1,176 +1,579 @@
-#define HEADSOCKET_IMPLEMENTATION
-#include "external/headsocket.h"
+#include <winsock2.h>
+#include <ws2tcpip.h>

 #include "websocket.h"
-#include "util/utils.h"
-#include "util/rc4.h"
-#include "util/logging.h"
-#include "overlay/notifications.h"
-#include "controller.h"

-using namespace headsocket;
+#include <algorithm>
+#include <array>
+#include <atomic>
+#include <cctype>
+#include <chrono>
+#include <cstring>
+#include <mutex>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include "external/wslay/msvc_compat.h"
+#include <wslay/wslay.h>
+
+#include "controller.h"
+#include "external/hash-library/sha1.h"
+#include "overlay/notifications.h"
+#include "util/crypt.h"
+#include "util/logging.h"

 namespace api {

-    /*
-     * Client class declaration
-     */
-    class WebSocketClient : public web_socket_client {
+    namespace {

-        // required class header
-        HEADSOCKET_CLIENT(WebSocketClient, web_socket_client);
+        constexpr int server_backlog = 4;
+        constexpr size_t client_limit = 8;

-    private:
-        ClientState *state = nullptr;
+        // a peer that connects and then says nothing must not hold a slot forever
+        constexpr int handshake_timeout_ms = 5000;
+        constexpr size_t request_size_limit = 8 * 1024;
+        constexpr uint64_t message_size_limit = 64 * 1024;

-    protected:
-        bool async_received_data(const data_block &db, uint8_t *ptr, size_t length) override;
+        // how long a quiet connection waits before the loop rechecks whether we are stopping
+        constexpr int idle_poll_ms = 500;

-        void on_accept() override;
-        void on_disconnect() override;
-    };
+        // RFC 6455 appends this to the client key before hashing
+        constexpr const char *websocket_guid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";

-    /*
-     * Server class declaration
-     */
-    class WebSocketServer : public web_socket_server<WebSocketClient> {
-        HEADSOCKET_SERVER(WebSocketServer, web_socket_server);
-    public:
-        WebSocketController *websocket;
-    };
+        constexpr double notification_throttle_seconds = 0.5;

-    void api::WebSocketServer::init() {}
+        std::string trim(const std::string &text) {
+            const auto begin = text.find_first_not_of(" \t");
+            if (begin == std::string::npos) {
+                return "";
+            }
+            return text.substr(begin, text.find_last_not_of(" \t") - begin + 1);
+        }
+
+        std::string to_lower(std::string text) {
+            std::transform(text.begin(), text.end(), text.begin(), [](unsigned char c) {
+                return static_cast<char>(std::tolower(c));
+            });
+            return text;
+        }
+
+        bool contains_token(const std::string &value, const std::string &expected) {
+            size_t pos = 0;
+            while (pos < value.size()) {
+                const size_t end = value.find(',', pos);
+                if (to_lower(trim(value.substr(pos, end - pos))) == expected) {
+                    return true;
+                }
+                if (end == std::string::npos) {
+                    break;
+                }
+                pos = end + 1;
+            }
+            return false;
+        }
+
+        bool valid_websocket_key(const std::string &key) {
+            if (key.size() != 24 || key[22] != '=' || key[23] != '=') {
+                return false;
+            }
+
+            const std::string alphabet =
+                    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+            for (size_t i = 0; i < 22; i++) {
+                if (alphabet.find(key[i]) == std::string::npos) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        bool send_all(SOCKET socket, const std::string &text) {
+            size_t remaining = text.size();
+            const char *cursor = text.data();
+
+            while (remaining > 0) {
+                const int sent = send(socket, cursor, static_cast<int>(remaining), 0);
+                if (sent <= 0) {
+                    return false;
+                }
+                cursor += sent;
+                remaining -= static_cast<size_t>(sent);
+            }
+
+            return true;
+        }
+
+        void set_recv_timeout(SOCKET socket, int milliseconds) {
+            const DWORD timeout = static_cast<DWORD>(milliseconds);
+            setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO,
+                    reinterpret_cast<const char *>(&timeout), sizeof(timeout));
+        }
+
+        std::string accept_key(const std::string &client_key) {
+            SHA1 sha1;
+            sha1.add(client_key.data(), client_key.size());
+            sha1.add(websocket_guid, strlen(websocket_guid));
+
+            unsigned char digest[SHA1::HashBytes] {};
+            sha1.getHash(digest);
+
+            return crypt::base64_encode(digest, sizeof(digest));
+        }
+
+        bool handshake(SOCKET socket) {
+            std::string request;
+            char byte = 0;
+            bool complete = false;
+
+            while (request.size() < request_size_limit) {
+                const int read = recv(socket, &byte, 1, 0);
+                if (read <= 0) {
+                    return false;
+                }
+
+                request.push_back(byte);
+                if (request.size() >= 4
+                        && request.compare(request.size() - 4, 4, "\r\n\r\n") == 0) {
+                    complete = true;
+                    break;
+                }
+            }
+
+            std::string key;
+            std::string version;
+            bool connection_upgrade = false;
+            bool upgrade = false;
+            const size_t request_line_end = request.find("\r\n");
+                const std::string request_line = request.substr(0, request_line_end);
+                const size_t target_end = request_line.find(' ', 4);
+                const bool valid_request_line = request_line_end != std::string::npos
+                    && request_line.compare(0, 4, "GET ") == 0
+                        && target_end != std::string::npos
+                    && target_end > 4
+                    && target_end == request_line.rfind(' ')
+                    && request_line.substr(target_end + 1) == "HTTP/1.1";
+            size_t pos = request_line_end;
+
+            while (pos != std::string::npos) {
+                const size_t end = request.find("\r\n", pos + 2);
+                if (end == std::string::npos || end == pos + 2) {
+                    break;
+                }
+
+                const std::string line = request.substr(pos + 2, end - pos - 2);
+                const size_t colon = line.find(':');
+                if (colon != std::string::npos) {
+                    const std::string name = to_lower(trim(line.substr(0, colon)));
+                    const std::string value = trim(line.substr(colon + 1));
+
+                    if (name == "sec-websocket-key") {
+                        key = value;
+                    } else if (name == "sec-websocket-version") {
+                        version = value;
+                    } else if (name == "connection") {
+                        connection_upgrade = connection_upgrade
+                                || contains_token(value, "upgrade");
+                    } else if (name == "upgrade") {
+                        upgrade = upgrade || contains_token(value, "websocket");
+                    }
+                }
+
+                pos = end;
+            }
+
+                if (!complete || !valid_request_line || !connection_upgrade || !upgrade
+                    || version != "13" || !valid_websocket_key(key)) {
+                send_all(socket,
+                        "HTTP/1.1 400 Bad Request\r\n"
+                        "Connection: close\r\n"
+                        "Content-Length: 0\r\n"
+                        "\r\n");
+                return false;
+            }
+
+            // deliberately echoes back no extension or subprotocol: naming one the client did
+            // not offer is a handshake failure, and none of them are wanted here
+            return send_all(socket,
+                    "HTTP/1.1 101 Switching Protocols\r\n"
+                    "Upgrade: websocket\r\n"
+                    "Connection: Upgrade\r\n"
+                    "Sec-WebSocket-Accept: " + accept_key(key) + "\r\n"
+                    "\r\n");
+        }
+
+        // everything one connection needs; wslay hands this back to the callbacks
+        struct Session {
+            SOCKET socket = INVALID_SOCKET;
+            Controller *controller = nullptr;
+            ClientState *state = nullptr;
+            bool failed = false;
+        };
+
+        ssize_t recv_callback(wslay_event_context_ptr ctx, uint8_t *buffer, size_t length,
+                int flags, void *user_data) {
+
+            (void) flags;
+
+            auto *session = static_cast<Session *>(user_data);
+            const int read = recv(session->socket, reinterpret_cast<char *>(buffer),
+                    static_cast<int>(length), 0);
+
+            if (read > 0) {
+                return read;
+            }
+
+            // the socket is non-blocking, so an empty one has to read as "nothing yet"
+            // rather than as a dead peer
+            if (read < 0 && WSAGetLastError() == WSAEWOULDBLOCK) {
+                wslay_event_set_error(ctx, WSLAY_ERR_WOULDBLOCK);
+                return -1;
+            }
+
+            wslay_event_set_error(ctx,
+                    read == 0 ? WSLAY_ERR_NO_MORE_MSG : WSLAY_ERR_CALLBACK_FAILURE);
+            return -1;
+        }
+
+        ssize_t send_callback(wslay_event_context_ptr ctx, const uint8_t *data, size_t length,
+                int flags, void *user_data) {
+
+            (void) flags;
+
+            auto *session = static_cast<Session *>(user_data);
+            const int sent = send(session->socket, reinterpret_cast<const char *>(data),
+                    static_cast<int>(length), 0);
+
+            if (sent > 0) {
+                return sent;
+            }
+
+            if (sent < 0 && WSAGetLastError() == WSAEWOULDBLOCK) {
+                wslay_event_set_error(ctx, WSLAY_ERR_WOULDBLOCK);
+                return -1;
+            }
+
+            wslay_event_set_error(ctx, WSLAY_ERR_CALLBACK_FAILURE);
+            return -1;
+        }
+
+        void on_msg_recv(wslay_event_context_ptr ctx,
+                const struct wslay_event_on_msg_recv_arg *arg, void *user_data) {
+
+            auto *session = static_cast<Session *>(user_data);
+
+            // pings and closes are wslay's business, it answers them itself
+            if (wslay_is_ctrl_frame(arg->opcode)) {
+                return;
+            }
+
+            if (arg->opcode != WSLAY_BINARY_FRAME) {
+                log_warning("api::websocket", "ignoring a non-binary message");
+                return;
+            }
+
+            std::vector<char> in(arg->msg, arg->msg + arg->msg_length);
+            std::vector<char> out;
+
+            if (session->state->cipher) {
+                session->state->cipher->crypt(
+                        reinterpret_cast<uint8_t *>(in.data()), in.size());
+            }
+
+            session->controller->process_request(session->state, &in, &out);
+
+            if (session->state->cipher) {
+                session->state->cipher->crypt(
+                        reinterpret_cast<uint8_t *>(out.data()), out.size());
+            }
+
+            wslay_event_msg reply {};
+            reply.opcode = WSLAY_BINARY_FRAME;
+            reply.msg = reinterpret_cast<const uint8_t *>(out.data());
+            reply.msg_length = out.size();
+
+            if (wslay_event_queue_msg(ctx, &reply) != 0) {
+                session->failed = true;
+                return;
+            }
+
+            Controller::process_password_change(session->state);
+        }
+    }

-    /*
-     * Controller state so we don't have to import headsocket stuff in our header
-     */
    struct WebSocketControllerState {
-        std::shared_ptr<WebSocketServer> server;
+        struct Client {
+            std::thread thread;
+            SOCKET socket = INVALID_SOCKET;
+            bool active = false;
+        };
+
+        Controller *controller = nullptr;
+        unsigned short port = 0;
+        SOCKET listener = INVALID_SOCKET;
+        bool wsa_started = false;
+        std::atomic_bool running { false };
+        std::thread acceptor;
+        std::mutex clients_m;
+        std::array<Client, client_limit> clients;
+
+        bool open_listener();
+        void accept_worker();
+        void client_worker(int slot, SOCKET socket, std::string address);
+        void stop();
    };

+    bool WebSocketControllerState::open_listener() {
+        WSADATA wsa_data;
+        const int error = WSAStartup(MAKEWORD(2, 2), &wsa_data);
+        if (error != 0) {
+            log_warning("api::websocket", "WSAStartup() returned {}", error);
+            return false;
+        }
+        this->wsa_started = true;
+
+        this->listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+        if (this->listener == INVALID_SOCKET) {
+            log_warning("api::websocket", "socket() returned {}", WSAGetLastError());
+            return false;
+        }
+
+        sockaddr_in address {};
+        address.sin_family = AF_INET;
+        address.sin_addr.s_addr = INADDR_ANY;
+        address.sin_port = htons(this->port);
+
+        if (bind(this->listener, reinterpret_cast<sockaddr *>(&address), sizeof(address))
+                == SOCKET_ERROR) {
+            log_warning("api::websocket", "bind() returned {}", WSAGetLastError());
+            return false;
+        }
+
+        if (listen(this->listener, server_backlog) == SOCKET_ERROR) {
+            log_warning("api::websocket", "listen() returned {}", WSAGetLastError());
+            return false;
+        }
+
+        return true;
+    }
+
+    void WebSocketControllerState::accept_worker() {
+
+        while (this->running) {
+            sockaddr_in client_address {};
+            int client_address_size = sizeof(sockaddr_in);
+
+            const SOCKET client = accept(
+                    this->listener, reinterpret_cast<sockaddr *>(&client_address),
+                    &client_address_size);
+
+            if (client == INVALID_SOCKET) {
+                // on shutdown the listener is closed under us; otherwise do not spin
+                if (this->running) {
+                    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+                }
+                continue;
+            }
+
+            if (!this->running) {
+                closesocket(client);
+                break;
+            }
+
+            // formatted by hand rather than with inet_ntop, which needs a newer Windows than
+            // the XP toolchain targets, or inet_ntoa, which answers from a shared buffer
+            const uint32_t raw = ntohl(client_address.sin_addr.s_addr);
+            const std::string address = fmt::format("{}.{}.{}.{}",
+                    (raw >> 24) & 0xff, (raw >> 16) & 0xff, (raw >> 8) & 0xff, raw & 0xff);
+
+            int slot = -1;
+            {
+                std::lock_guard<std::mutex> lock(this->clients_m);
+                for (size_t i = 0; i < this->clients.size(); i++) {
+                    if (!this->clients[i].active) {
+                        this->clients[i].active = true;
+                        this->clients[i].socket = client;
+                        slot = static_cast<int>(i);
+                        break;
+                    }
+                }
+            }
+
+            if (slot < 0) {
+                log_warning("api::websocket", "client limit of {} hit", client_limit);
+                overlay::notifications::add_throttled(
+                        overlay::notifications::Severity::Warning,
+                        "api::websocket.client_limit",
+                        notification_throttle_seconds,
+                        fmt::format("API websocket refused: client limit reached ({})", address));
+                closesocket(client);
+                continue;
+            }
+
+            // this thread is the only one that touches the thread objects, so the slot's
+            // previous occupant gets reaped here rather than being detached
+            if (this->clients[slot].thread.joinable()) {
+                this->clients[slot].thread.join();
+            }
+
+            // the handshake runs on the client thread on purpose: doing it here would put
+            // every later connection behind whatever this one is waiting for
+            this->clients[slot].thread = std::thread([this, slot, client, address] {
+                this->client_worker(slot, client, address);
+            });
+        }
+    }
+
+    void WebSocketControllerState::client_worker(int slot, SOCKET socket, std::string address) {
+
+        // wslay writes a frame header and its payload as separate sends, so leaving Nagle on
+        // holds the payload back until the peer acknowledges the header, costing a delayed
+        // ack per message; requests here are small and latency sensitive
+        int nodelay = 1;
+        setsockopt(socket, IPPROTO_TCP, TCP_NODELAY,
+                reinterpret_cast<const char *>(&nodelay), sizeof(nodelay));
+
+        set_recv_timeout(socket, handshake_timeout_ms);
+
+        if (handshake(socket)) {
+            // wslay reads until the socket would block, so leaving it blocking would make
+            // every reply wait out a receive timeout before the send got a turn
+            u_long non_blocking = 1;
+            ioctlsocket(socket, FIONBIO, &non_blocking);
+
+            Session session;
+            session.socket = socket;
+            session.controller = this->controller;
+            session.state = new ClientState();
+            this->controller->init_state(session.state);
+
+            log_info("api::websocket", "client connected: {}", address);
+            overlay::notifications::add(
+                    overlay::notifications::Severity::Success,
+                    fmt::format("API websocket client connected ({})", address));
+
+            wslay_event_callbacks callbacks {};
+            callbacks.recv_callback = recv_callback;
+            callbacks.send_callback = send_callback;
+            callbacks.on_msg_recv_callback = on_msg_recv;
+
+            wslay_event_context_ptr ctx = nullptr;
+            if (wslay_event_context_server_init(&ctx, &callbacks, &session) == 0) {
+                wslay_event_config_set_max_recv_msg_length(ctx, message_size_limit);
+                while (this->running && !session.failed
+                        && (wslay_event_want_read(ctx) || wslay_event_want_write(ctx))) {
+
+                    fd_set read_set;
+                    fd_set write_set;
+                    FD_ZERO(&read_set);
+                    FD_ZERO(&write_set);
+
+                    if (wslay_event_want_read(ctx)) {
+                        FD_SET(socket, &read_set);
+                    }
+                    if (wslay_event_want_write(ctx)) {
+                        FD_SET(socket, &write_set);
+                    }
+
+                    // bounded so a silent connection still notices us shutting down
+                    timeval timeout {};
+                    timeout.tv_usec = idle_poll_ms * 1000;
+
+                    if (select(0, &read_set, &write_set, nullptr, &timeout) < 0) {
+                        break;
+                    }
+
+                    if (FD_ISSET(socket, &read_set) && wslay_event_recv(ctx) != 0) {
+                        break;
+                    }
+
+                    // unconditional, so a reply queued by the read above goes out now
+                    if (wslay_event_send(ctx) != 0) {
+                        break;
+                    }
+                }
+
+                wslay_event_context_free(ctx);
+            }
+
+            Controller::free_state(session.state);
+            delete session.state;
+
+            log_info("api::websocket", "client disconnected: {}", address);
+            overlay::notifications::add(
+                    overlay::notifications::Severity::Info,
+                    fmt::format("API websocket client disconnected ({})", address));
+        }
+
+        closesocket(socket);
+
+        std::lock_guard<std::mutex> lock(this->clients_m);
+        this->clients[slot].socket = INVALID_SOCKET;
+        this->clients[slot].active = false;
+    }
+
+    void WebSocketControllerState::stop() {
+        this->running = false;
+
+        if (this->listener != INVALID_SOCKET) {
+            closesocket(this->listener);
+            this->listener = INVALID_SOCKET;
+        }
+
+        // drops the client threads out of their blocking send/recv
+        {
+            std::lock_guard<std::mutex> lock(this->clients_m);
+            for (auto &client : this->clients) {
+                if (client.socket != INVALID_SOCKET) {
+                    ::shutdown(client.socket, SD_BOTH);
+                }
+            }
+        }
+
+        if (this->acceptor.joinable()) {
+            this->acceptor.join();
+        }
+
+        // joining is what guarantees no client thread outlives this object
+        for (auto &client : this->clients) {
+            if (client.thread.joinable()) {
+                client.thread.join();
+            }
+        }
+
+        if (this->wsa_started) {
+            WSACleanup();
+            this->wsa_started = false;
+        }
+    }
+
    WebSocketController::WebSocketController(Controller *controller, uint16_t port) {
        this->controller = controller;

-        // create state
        this->state = new WebSocketControllerState();
+        this->state->controller = controller;
+        this->state->port = port;

-        // start server
-        this->state->server = WebSocketServer::create(port);
-        this->state->server->websocket = this;
-        if (this->state->server->is_running()) {
-            log_info("api::websocket", "server listening on port: {}", port);
-        } else {
+        if (!this->state->open_listener()) {
            log_warning("api::websocket", "server failed to listen on port: {}", port);
+            return;
        }
+
+        this->state->running = true;
+        this->state->acceptor = std::thread([this] {
+            this->state->accept_worker();
+        });
+
+        log_info("api::websocket", "server listening on port: {}", port);
    }

    WebSocketController::~WebSocketController() {
-
-        // stop server
-        this->state->server->stop();
-
-        // delete state
+        this->state->stop();
        delete this->state;
+        this->state = nullptr;
    }

    void WebSocketController::free_socket() {
-        this->state->server->stop();
-    }
-
-    void WebSocketClient::on_accept() {
-        web_socket_client::on_accept();
-
-        // get pointer to server
-        auto srv = reinterpret_cast<WebSocketServer *>(server().get());
-        if (!srv || !srv->websocket) {
-            log_fatal("api::websocket", "on_accept has no server");
-        }
-
-        // check for init
-        state = new ClientState();
-        srv->websocket->controller->init_state(state);
-
-        // log connection
-        log_info("api::websocket", "client connected");
-        overlay::notifications::add(
-                overlay::notifications::Severity::Success,
-                "API websocket client connected");
-    }
-
-    void WebSocketClient::on_disconnect() {
-
-        // log disconnection
-        log_info("api::websocket", "client disconnected");
-        overlay::notifications::add(
-                overlay::notifications::Severity::Info,
-                "API websocket client disconnected");
-
-        // get pointer to server
-        auto srv = reinterpret_cast<WebSocketServer *>(server().get());
-        if (!srv || !srv->websocket) {
-            log_fatal("api::websocket", "on_disconnect has no server");
-        }
-
-        // clean up state
-        srv->websocket->controller->free_state(state);
-        delete state;
-        state = nullptr;
-
-        // call super
-        web_socket_client::on_disconnect();
-    }
-
-    /*
-     * This is where business actually happens, gets called on every datablock receive
-     */
-    bool WebSocketClient::async_received_data(const data_block &db, uint8_t *ptr, size_t length) {
-
-        // get pointer to server
-        auto srv = reinterpret_cast<WebSocketServer *>(server().get());
-        if (!srv || !srv->websocket) {
-            log_fatal("api::websocket", "received datablock without server");
-        }
-
-        // check state
-        if (!state) {
-            log_fatal("api::websocket", "client with no state received datablock");
-        }
-
-        // check datablock type
-        switch (db.op) {
-            case opcode::binary: {
-
-                // allocate buffers
-                std::vector<char> in(ptr, ptr + length);
-                std::vector<char> out;
-
-                // crypt in-data
-                if (state->cipher) {
-                    state->cipher->crypt(reinterpret_cast<uint8_t *>(in.data()), in.size());
-                }
-
-                // process request
-                srv->websocket->controller->process_request(state, &in, &out);
-
-                // crypt out-data
-                if (state->cipher) {
-                    state->cipher->crypt(reinterpret_cast<uint8_t *>(out.data()), out.size());
-                }
-
-                // send answer
-                push(out.data(), out.size());
-
-                // check for password change
-                srv->websocket->controller->process_password_change(state);
-
-                break;
-            }
-            default:
-                log_warning("api::websocket", "datablock received with non-binary type");
-                break;
-        }
-
-        // always consume the datablock, nomnom
-        return true;
+        this->state->stop();
    }
 }
@@ -573,6 +573,13 @@ static inline void easrv_init_messages() {
            "\x5b\x99\xa1\x15\x78\x16\x84\xe0\x67\x2c\x75\xf7\xc0\x38\xd5\x20\xf7\x81\xae\x1f\x77\x02\xdf\x0c"
            "\x60\x68\x2e\x26\xe5\xbb\xb7\xb4\x41\x72\xc4\xa4\x43\x2a\xc8\x81\xd3\x8a\x1f\xe8\x94\x39\x7e\xf6"
            "\x69\x56\x9e\xaf\x06\x10\xfd\x47\x69\xb8\x14\xe6\x48\x36\xd6\x25\x18\x0c\x2b\x3d\x69");
+    if (avs::game::is_model("UDN")) {
+        // Only UDN needs an ASCII location/name for the Unity score-screen marshaler.
+        // These 12 encoded bytes replace the name with "SPICE2 LOCAL";
+        // its terminator, the other fields and the response length stay unchanged.
+        EA_FACILITY_GET.replace(311, 12,
+                "\xf2\x20\xcc\x9a\xe3\x32\x78\x80\x9a\xba\xcd\xc3");
+    }
    EA_PCBEVENT_PUT = std::string(
            "\x17\x7e\x7c\x0e\x1a\x15\x41\x0b\xae\xd5\xa0\xf5\x2c\xa1\xb9\xd2\x53\xca\xd2\x0d\x81\x34\xdb\x94\x79\xd0"
            "\xc8\x9d\xb5\xfb\xef\x97");
@@ -24,3 +24,12 @@ ENV PATH="$PATH:/opt/llvm-mingw-xp/bin"

 RUN curl -fsSL "https://github.com/mon/windows-dll-compat-checker/releases/download/v1.3/windows_dll_compat_checker-linux-x86_64.tar.xz" \
    | tar -xJ -C /usr/local/bin
+
+# Stock makepkg.conf builds serially; this makes the AUR compiles below parallel.
+RUN printf '%s\n' 'MAKEFLAGS="-j$(nproc)"' > /home/user/.makepkg.conf \
+    && chown user: /home/user/.makepkg.conf
+
+# libjpeg-turbo for JPEG encoding, x264 for the API H.264 video stream. Only the
+# mingw-w64 toolchains get these; the WinXP targets build without JPEG support
+# and without the stream encoder.
+RUN su user -c "yay --noconfirm -S mingw-w64-libjpeg-turbo mingw-w64-x264"
@@ -1,143 +0,0 @@
-# Minimal build for the vendored libjpeg-turbo.
-# Upstream's CMake pulls in Java bindings, tools, tests and packaging and sets
-# its own global flags, none of which survive contact with this project's four
-# cross toolchains, so only the static library is described here.
-
-set(LJT_VERSION "3.0.4")
-set(VERSION ${LJT_VERSION})
-set(JPEG_LIB_VERSION 62)
-set(LIBJPEG_TURBO_VERSION_NUMBER 3000004)
-set(BUILD "spice2x")
-
-set(C_ARITH_CODING_SUPPORTED 1)
-set(D_ARITH_CODING_SUPPORTED 1)
-
-if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-    set(LJT_ARCH "x86_64")
-else()
-    set(LJT_ARCH "i386")
-endif()
-
-# SIMD is the entire reason for taking this dependency, but a missing assembler
-# must not break the build; the C paths are still correct, just slower.
-# ASM_NASM is enabled by the top level CMakeLists.
-if(CMAKE_ASM_NASM_COMPILER)
-    set(WITH_SIMD 1)
-else()
-    message(WARNING "nasm not found, building libjpeg-turbo without SIMD (screen capture will be slower)")
-endif()
-
-if(MSVC)
-    set(HIDDEN "")
-    set(INLINE "__forceinline")
-    set(THREAD_LOCAL "__declspec(thread)")
-    set(HAVE_INTRIN_H 1)
-else()
-    set(HIDDEN "__attribute__((visibility(\"hidden\")))")
-    set(INLINE "inline __attribute__((always_inline))")
-    set(THREAD_LOCAL "__thread")
-    set(HAVE_BUILTIN_CTZL 1)
-endif()
-
-set(SIZE_T ${CMAKE_SIZEOF_VOID_P})
-
-configure_file(jconfig.h.in ${CMAKE_CURRENT_BINARY_DIR}/jconfig.h)
-configure_file(jconfigint.h.in ${CMAKE_CURRENT_BINARY_DIR}/jconfigint.h)
-configure_file(jversion.h.in ${CMAKE_CURRENT_BINARY_DIR}/jversion.h)
-
-# libjpeg-turbo 3.x supports 8, 12 and 16 bit samples by compiling the
-# precision dependent units once per precision; jcinit.c dispatches to all
-# three at runtime, so none of them can be dropped.
-# jstdhuff.c and the *ext.c units are textually included and never compiled.
-set(JPEG16_SOURCES
-        jcapistd.c jccolor.c jcdiffct.c jclossls.c jcmainct.c jcprepct.c
-        jcsample.c jdapistd.c jdcolor.c jddiffct.c jdlossls.c jdmainct.c
-        jdpostct.c jdsample.c jutils.c)
-
-set(JPEG12_SOURCES ${JPEG16_SOURCES}
-        jccoefct.c jcdctmgr.c jdcoefct.c jddctmgr.c jdmerge.c jfdctfst.c
-        jfdctint.c jidctflt.c jidctfst.c jidctint.c jidctred.c jquant1.c
-        jquant2.c)
-
-set(JPEG_SOURCES ${JPEG12_SOURCES}
-        jcapimin.c jchuff.c jcicc.c jcinit.c jclhuff.c jcmarker.c jcmaster.c
-        jcomapi.c jcparam.c jcphuff.c jctrans.c jdapimin.c jdatadst.c
-        jdatasrc.c jdhuff.c jdicc.c jdinput.c jdlhuff.c jdmarker.c jdmaster.c
-        jdphuff.c jdtrans.c jerror.c jfdctflt.c jmemmgr.c jmemnobs.c
-        jpeg_nbits.c
-        jaricom.c jcarith.c jdarith.c)
-
-if(WITH_SIMD)
-    # the *ext-*.asm units are textually included by these, so the list is
-    # explicit rather than globbed
-    if(LJT_ARCH STREQUAL "x86_64")
-        set(LJT_SIMD_ASM
-                x86_64/jsimdcpu.asm x86_64/jfdctflt-sse.asm
-                x86_64/jccolor-sse2.asm x86_64/jcgray-sse2.asm x86_64/jchuff-sse2.asm
-                x86_64/jcphuff-sse2.asm x86_64/jcsample-sse2.asm x86_64/jdcolor-sse2.asm
-                x86_64/jdmerge-sse2.asm x86_64/jdsample-sse2.asm x86_64/jfdctfst-sse2.asm
-                x86_64/jfdctint-sse2.asm x86_64/jidctflt-sse2.asm x86_64/jidctfst-sse2.asm
-                x86_64/jidctint-sse2.asm x86_64/jidctred-sse2.asm x86_64/jquantf-sse2.asm
-                x86_64/jquanti-sse2.asm
-                x86_64/jccolor-avx2.asm x86_64/jcgray-avx2.asm x86_64/jcsample-avx2.asm
-                x86_64/jdcolor-avx2.asm x86_64/jdmerge-avx2.asm x86_64/jdsample-avx2.asm
-                x86_64/jfdctint-avx2.asm x86_64/jidctint-avx2.asm x86_64/jquanti-avx2.asm)
-    else()
-        set(LJT_SIMD_ASM
-                i386/jsimdcpu.asm i386/jfdctflt-3dn.asm
-                i386/jidctflt-3dn.asm i386/jquant-3dn.asm
-                i386/jccolor-mmx.asm i386/jcgray-mmx.asm i386/jcsample-mmx.asm
-                i386/jdcolor-mmx.asm i386/jdmerge-mmx.asm i386/jdsample-mmx.asm
-                i386/jfdctfst-mmx.asm i386/jfdctint-mmx.asm i386/jidctfst-mmx.asm
-                i386/jidctint-mmx.asm i386/jidctred-mmx.asm i386/jquant-mmx.asm
-                i386/jfdctflt-sse.asm i386/jidctflt-sse.asm i386/jquant-sse.asm
-                i386/jccolor-sse2.asm i386/jcgray-sse2.asm i386/jchuff-sse2.asm
-                i386/jcphuff-sse2.asm i386/jcsample-sse2.asm i386/jdcolor-sse2.asm
-                i386/jdmerge-sse2.asm i386/jdsample-sse2.asm i386/jfdctfst-sse2.asm
-                i386/jfdctint-sse2.asm i386/jidctflt-sse2.asm i386/jidctfst-sse2.asm
-                i386/jidctint-sse2.asm i386/jidctred-sse2.asm i386/jquantf-sse2.asm
-                i386/jquanti-sse2.asm
-                i386/jccolor-avx2.asm i386/jcgray-avx2.asm i386/jcsample-avx2.asm
-                i386/jdcolor-avx2.asm i386/jdmerge-avx2.asm i386/jdsample-avx2.asm
-                i386/jfdctint-avx2.asm i386/jidctint-avx2.asm i386/jquanti-avx2.asm)
-    endif()
-
-    list(TRANSFORM LJT_SIMD_ASM PREPEND "${CMAKE_CURRENT_SOURCE_DIR}/simd/")
-    list(APPEND JPEG_SOURCES simd/${LJT_ARCH}/jsimd.c ${LJT_SIMD_ASM})
-
-    # nasm resolves %include against these, and requires the trailing separator
-    set(CMAKE_ASM_NASM_FLAGS
-            "${CMAKE_ASM_NASM_FLAGS} -I${CMAKE_CURRENT_SOURCE_DIR}/simd/nasm/ -I${CMAKE_CURRENT_SOURCE_DIR}/simd/${LJT_ARCH}/")
-
-    if(LJT_ARCH STREQUAL "x86_64")
-        set(CMAKE_ASM_NASM_OBJECT_FORMAT win64)
-        set(CMAKE_ASM_NASM_FLAGS "${CMAKE_ASM_NASM_FLAGS} -D__x86_64__ -DWIN64")
-    else()
-        set(CMAKE_ASM_NASM_OBJECT_FORMAT win32)
-        set(CMAKE_ASM_NASM_FLAGS "${CMAKE_ASM_NASM_FLAGS} -DWIN32")
-    endif()
-endif()
-
-add_library(jpeg12-static OBJECT ${JPEG12_SOURCES})
-set_property(TARGET jpeg12-static PROPERTY COMPILE_FLAGS "-DBITS_IN_JSAMPLE=12")
-
-add_library(jpeg16-static OBJECT ${JPEG16_SOURCES})
-set_property(TARGET jpeg16-static PROPERTY COMPILE_FLAGS "-DBITS_IN_JSAMPLE=16")
-
-add_library(jpeg-static STATIC ${JPEG_SOURCES}
-        $<TARGET_OBJECTS:jpeg12-static>
-        $<TARGET_OBJECTS:jpeg16-static>)
-
-foreach(ljt_target jpeg-static jpeg12-static jpeg16-static)
-    target_include_directories(${ljt_target} PUBLIC
-            ${CMAKE_CURRENT_SOURCE_DIR}
-            ${CMAKE_CURRENT_BINARY_DIR})
-
-    target_include_directories(${ljt_target} PRIVATE
-            ${CMAKE_CURRENT_SOURCE_DIR}/simd
-            ${CMAKE_CURRENT_SOURCE_DIR}/simd/${LJT_ARCH})
-
-    if(NOT MSVC)
-        target_compile_options(${ljt_target} PRIVATE -Wno-unused-parameter -Wno-sign-compare)
-    endif()
-endforeach()
@@ -1,135 +0,0 @@
-libjpeg-turbo Licenses
-======================
-
-libjpeg-turbo is covered by two compatible BSD-style open source licenses:
-
- The IJG (Independent JPEG Group) License, which is listed in
-  [README.ijg](README.ijg)
-
-  This license applies to the libjpeg API library and associated programs,
-  including any code inherited from libjpeg and any modifications to that
-  code.  Note that the libjpeg-turbo SIMD source code bears the
-  [zlib License](https://opensource.org/licenses/Zlib), but in the context of
-  the overall libjpeg API library, the terms of the zlib License are subsumed
-  by the terms of the IJG License.
-
- The Modified (3-clause) BSD License, which is listed below
-
-  This license applies to the TurboJPEG API library and associated programs, as
-  well as the build system.  Note that the TurboJPEG API library wraps the
-  libjpeg API library, so in the context of the overall TurboJPEG API library,
-  both the terms of the IJG License and the terms of the Modified (3-clause)
-  BSD License apply.
-
-
-Complying with the libjpeg-turbo Licenses
-=========================================
-
-This section provides a roll-up of the libjpeg-turbo licensing terms, to the
-best of our understanding.  This is not a license in and of itself.  It is
-intended solely for clarification.
-
-1.  If you are distributing a modified version of the libjpeg-turbo source,
-    then:
-
-    1.  You cannot alter or remove any existing copyright or license notices
-        from the source.
-
-        **Origin**
-        - Clause 1 of the IJG License
-        - Clause 1 of the Modified BSD License
-        - Clauses 1 and 3 of the zlib License
-
-    2.  You must add your own copyright notice to the header of each source
-        file you modified, so others can tell that you modified that file.  (If
-        there is not an existing copyright header in that file, then you can
-        simply add a notice stating that you modified the file.)
-
-        **Origin**
-        - Clause 1 of the IJG License
-        - Clause 2 of the zlib License
-
-    3.  You must include the IJG README file, and you must not alter any of the
-        copyright or license text in that file.
-
-        **Origin**
-        - Clause 1 of the IJG License
-
-2.  If you are distributing only libjpeg-turbo binaries without the source, or
-    if you are distributing an application that statically links with
-    libjpeg-turbo, then:
-
-    1.  Your product documentation must include a message stating:
-
-        This software is based in part on the work of the Independent JPEG
-        Group.
-
-        **Origin**
-        - Clause 2 of the IJG license
-
-    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.)
-
-        **Origin**
-        - Clause 2 of the Modified BSD License
-
-3.  You cannot use the name of the IJG or The libjpeg-turbo Project or the
-    contributors thereof in advertising, publicity, etc.
-
-    **Origin**
-    - IJG License
-    - Clause 3 of the Modified BSD License
-
-4.  The IJG and The libjpeg-turbo Project do not warrant libjpeg-turbo to be
-    free of defects, nor do we accept any liability for undesirable
-    consequences resulting from your use of the software.
-
-    **Origin**
-    - IJG License
-    - Modified BSD License
-    - zlib License
-
-
-The Modified (3-clause) BSD License
-===================================
-
-Copyright (C)2009-2023 D. R. Commander.  All Rights Reserved.<br>
-Copyright (C)2015 Viktor Szathmáry.  All Rights Reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- Redistributions of source code must retain the above copyright notice,
-  this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice,
-  this list of conditions and the following disclaimer in the documentation
-  and/or other materials provided with the distribution.
- Neither the name of the libjpeg-turbo Project nor the names of its
-  contributors may be used to endorse or promote products derived from this
-  software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS",
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGE.
-
-
-Why Two Licenses?
-=================
-
-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.
@@ -1,258 +0,0 @@
-libjpeg-turbo note:  This file has been modified by The libjpeg-turbo Project
-to include only information relevant to libjpeg-turbo, to wordsmith certain
-sections, and to remove impolitic language that existed in the libjpeg v8
-README.  It is included only for reference.  Please see README.md for
-information specific to libjpeg-turbo.
-
-
-The Independent JPEG Group's JPEG software
-==========================================
-
-This distribution contains a release of the Independent JPEG Group's free JPEG
-software.  You are welcome to redistribute this software and to use it for any
-purpose, subject to the conditions under LEGAL ISSUES, below.
-
-This software is the work of Tom Lane, Guido Vollbeding, Philip Gladstone,
-Bill Allombert, Jim Boucher, Lee Crocker, Bob Friesenhahn, Ben Jackson,
-Julian Minguillon, Luis Ortiz, George Phillips, Davide Rossi, Ge' Weijers,
-and other members of the Independent JPEG Group.
-
-IJG is not affiliated with the ISO/IEC JTC1/SC29/WG1 standards committee
-(also known as JPEG, together with ITU-T SG16).
-
-
-DOCUMENTATION ROADMAP
-=====================
-
-This file contains the following sections:
-
-OVERVIEW            General description of JPEG and the IJG software.
-LEGAL ISSUES        Copyright, lack of warranty, terms of distribution.
-REFERENCES          Where to learn more about JPEG.
-ARCHIVE LOCATIONS   Where to find newer versions of this software.
-FILE FORMAT WARS    Software *not* to get.
-TO DO               Plans for future IJG releases.
-
-Other documentation files in the distribution are:
-
-User documentation:
-  usage.txt         Usage instructions for cjpeg, djpeg, jpegtran,
-                    rdjpgcom, and wrjpgcom.
-  *.1               Unix-style man pages for programs (same info as usage.txt).
-  wizard.txt        Advanced usage instructions for JPEG wizards only.
-  change.log        Version-to-version change highlights.
-Programmer and internal documentation:
-  libjpeg.txt       How to use the JPEG library in your own programs.
-  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.
-
-Please read at least usage.txt.  Some information can also be found in the JPEG
-FAQ (Frequently Asked Questions) article.  See ARCHIVE LOCATIONS below to find
-out where to obtain the FAQ article.
-
-If you want to understand how the JPEG code works, we suggest reading one or
-more of the REFERENCES, then looking at the documentation files (in roughly
-the order listed) before diving into the code.
-
-
-OVERVIEW
-========
-
-This package contains C software to implement JPEG image encoding, decoding,
-and transcoding.  JPEG (pronounced "jay-peg") is a standardized compression
-method for full-color and grayscale images.  JPEG's strong suit is compressing
-photographic images or other types of images that have smooth color and
-brightness transitions between neighboring pixels.  Images with sharp lines or
-other abrupt features may not compress well with JPEG, and a higher JPEG
-quality may have to be used to avoid visible compression artifacts with such
-images.
-
-JPEG is normally lossy, meaning that the output pixels are not necessarily
-identical to the input pixels.  However, on photographic content and other
-"smooth" images, very good compression ratios can be obtained with no visible
-compression artifacts, and extremely high compression ratios are possible if
-you are willing to sacrifice image quality (by reducing the "quality" setting
-in the compressor.)
-
-This software implements JPEG baseline, extended-sequential, progressive, and
-lossless compression processes.  Provision is made for supporting all variants
-of these processes, although some uncommon parameter settings aren't
-implemented yet.  We have made no provision for supporting the hierarchical
-processes defined in the standard.
-
-We provide a set of library routines for reading and writing JPEG image files,
-plus two sample applications "cjpeg" and "djpeg", which use the library to
-perform conversion between JPEG and some other popular image file formats.
-The library is intended to be reused in other applications.
-
-In order to support file conversion and viewing software, we have included
-considerable functionality beyond the bare JPEG coding/decoding capability;
-for example, the color quantization modules are not strictly part of JPEG
-decoding, but they are essential for output to colormapped file formats.  These
-extra functions can be compiled out of the library if not required for a
-particular application.
-
-We have also included "jpegtran", a utility for lossless transcoding between
-different JPEG processes, and "rdjpgcom" and "wrjpgcom", two simple
-applications for inserting and extracting textual comments in JFIF files.
-
-The emphasis in designing this software has been on achieving portability and
-flexibility, while also making it fast enough to be useful.  In particular,
-the software is not intended to be read as a tutorial on JPEG.  (See the
-REFERENCES section for introductory material.)  Rather, it is intended to
-be reliable, portable, industrial-strength code.  We do not claim to have
-achieved that goal in every aspect of the software, but we strive for it.
-
-We welcome the use of this software as a component of commercial products.
-No royalty is required, but we do ask for an acknowledgement in product
-documentation, as described under LEGAL ISSUES.
-
-
-LEGAL ISSUES
-============
-
-In plain English:
-
-1. We don't promise that this software works.  (But if you find any bugs,
-   please let us know!)
-2. You can use this software for whatever you want.  You don't have to pay us.
-3. You may not pretend that you wrote this software.  If you use it in a
-   program, you must acknowledge somewhere in your documentation that
-   you've used the IJG code.
-
-In legalese:
-
-The authors make NO WARRANTY or representation, either express or implied,
-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.
-All Rights Reserved except as specified below.
-
-Permission is hereby granted to use, copy, modify, and distribute this
-software (or portions thereof) for any purpose, without fee, subject to these
-conditions:
-(1) If any part of the source code for this software is distributed, then this
-README file must be included, with this copyright and no-warranty notice
-unaltered; and any additions, deletions, or changes to the original files
-must be clearly indicated in accompanying documentation.
-(2) If only executable code is distributed, then the accompanying
-documentation must state that "this software is based in part on the work of
-the Independent JPEG Group".
-(3) Permission for use of this software is granted only if the user accepts
-full responsibility for any undesirable consequences; the authors accept
-NO LIABILITY for damages of any kind.
-
-These conditions apply to any software derived from or based on the IJG code,
-not just to the unmodified library.  If you use our work, you ought to
-acknowledge us.
-
-Permission is NOT granted for the use of any IJG author's name or company name
-in advertising or publicity relating to this software or products derived from
-it.  This software may be referred to only as "the Independent JPEG Group's
-software".
-
-We specifically permit and encourage the use of this software as the basis of
-commercial products, provided that all warranty or liability claims are
-assumed by the product vendor.
-
-
-REFERENCES
-==========
-
-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.
-(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
-available at http://www.ijg.org/files/Wallace.JPEG.pdf.  The file (actually
-a preprint for an article that appeared in IEEE Trans. Consumer Electronics)
-omits the sample images that appeared in CACM, but it includes corrections
-and some added material.  Note: the Wallace article is copyright ACM and IEEE,
-and it may not be used for commercial purposes.
-
-A somewhat less technical, more leisurely introduction to JPEG can be found in
-"The Data Compression Book" by Mark Nelson and Jean-loup Gailly, published by
-M&T Books (New York), 2nd ed. 1996, ISBN 1-55851-434-1.  This book provides
-good explanations and example C code for a multitude of compression methods
-including JPEG.  It is an excellent source if you are comfortable reading C
-code but don't know much about data compression in general.  The book's JPEG
-sample code is far from industrial-strength, but when you are ready to look
-at a full implementation, you've got one here...
-
-The best currently available description of JPEG is the textbook "JPEG Still
-Image Data Compression Standard" by William B. Pennebaker and Joan L.
-Mitchell, published by Van Nostrand Reinhold, 1993, ISBN 0-442-01272-1.
-Price US$59.95, 638 pp.  The book includes the complete text of the ISO JPEG
-standards (DIS 10918-1 and draft DIS 10918-2).
-
-The original JPEG standard is divided into two parts, Part 1 being the actual
-specification, while Part 2 covers compliance testing methods.  Part 1 is
-titled "Digital Compression and Coding of Continuous-tone Still Images,
-Part 1: Requirements and guidelines" and has document numbers ISO/IEC IS
-10918-1, ITU-T T.81.  Part 2 is titled "Digital Compression and Coding of
-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.
-
-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
-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
-uses our library to implement TIFF/JPEG per the Note.
-
-
-ARCHIVE LOCATIONS
-=================
-
-The "official" archive site for this software is www.ijg.org.
-The most recent released version can always be found there in
-directory "files".
-
-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.
-
-
-FILE FORMAT COMPATIBILITY
-=========================
-
-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 original 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.
-
-
-TO DO
-=====
-
-Please send bug reports, offers of help, etc. to jpeg-info@jpegclub.org.
@@ -1,157 +0,0 @@
-/*
- * jaricom.c
- *
- * 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.
- * 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.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-
-/* The following #define specifies the packing of the four components
- * into the compact JLONG representation.
- * Note that this formula must match the actual arithmetic encoder
- * and decoder implementation.  The implementation has to be changed
- * if this formula is changed.
- * The current organization is leaned on Markus Kuhn's JBIG
- * implementation (jbig_tab.c).
- */
-
-#define V(i, a, b, c, d) \
-  (((JLONG)a << 16) | ((JLONG)c << 8) | ((JLONG)d << 7) | b)
-
-const JLONG jpeg_aritab[113 + 1] = {
-/*
- * Index, Qe_Value, Next_Index_LPS, Next_Index_MPS, Switch_MPS
- */
-  V(   0, 0x5a1d,   1,   1, 1 ),
-  V(   1, 0x2586,  14,   2, 0 ),
-  V(   2, 0x1114,  16,   3, 0 ),
-  V(   3, 0x080b,  18,   4, 0 ),
-  V(   4, 0x03d8,  20,   5, 0 ),
-  V(   5, 0x01da,  23,   6, 0 ),
-  V(   6, 0x00e5,  25,   7, 0 ),
-  V(   7, 0x006f,  28,   8, 0 ),
-  V(   8, 0x0036,  30,   9, 0 ),
-  V(   9, 0x001a,  33,  10, 0 ),
-  V(  10, 0x000d,  35,  11, 0 ),
-  V(  11, 0x0006,   9,  12, 0 ),
-  V(  12, 0x0003,  10,  13, 0 ),
-  V(  13, 0x0001,  12,  13, 0 ),
-  V(  14, 0x5a7f,  15,  15, 1 ),
-  V(  15, 0x3f25,  36,  16, 0 ),
-  V(  16, 0x2cf2,  38,  17, 0 ),
-  V(  17, 0x207c,  39,  18, 0 ),
-  V(  18, 0x17b9,  40,  19, 0 ),
-  V(  19, 0x1182,  42,  20, 0 ),
-  V(  20, 0x0cef,  43,  21, 0 ),
-  V(  21, 0x09a1,  45,  22, 0 ),
-  V(  22, 0x072f,  46,  23, 0 ),
-  V(  23, 0x055c,  48,  24, 0 ),
-  V(  24, 0x0406,  49,  25, 0 ),
-  V(  25, 0x0303,  51,  26, 0 ),
-  V(  26, 0x0240,  52,  27, 0 ),
-  V(  27, 0x01b1,  54,  28, 0 ),
-  V(  28, 0x0144,  56,  29, 0 ),
-  V(  29, 0x00f5,  57,  30, 0 ),
-  V(  30, 0x00b7,  59,  31, 0 ),
-  V(  31, 0x008a,  60,  32, 0 ),
-  V(  32, 0x0068,  62,  33, 0 ),
-  V(  33, 0x004e,  63,  34, 0 ),
-  V(  34, 0x003b,  32,  35, 0 ),
-  V(  35, 0x002c,  33,   9, 0 ),
-  V(  36, 0x5ae1,  37,  37, 1 ),
-  V(  37, 0x484c,  64,  38, 0 ),
-  V(  38, 0x3a0d,  65,  39, 0 ),
-  V(  39, 0x2ef1,  67,  40, 0 ),
-  V(  40, 0x261f,  68,  41, 0 ),
-  V(  41, 0x1f33,  69,  42, 0 ),
-  V(  42, 0x19a8,  70,  43, 0 ),
-  V(  43, 0x1518,  72,  44, 0 ),
-  V(  44, 0x1177,  73,  45, 0 ),
-  V(  45, 0x0e74,  74,  46, 0 ),
-  V(  46, 0x0bfb,  75,  47, 0 ),
-  V(  47, 0x09f8,  77,  48, 0 ),
-  V(  48, 0x0861,  78,  49, 0 ),
-  V(  49, 0x0706,  79,  50, 0 ),
-  V(  50, 0x05cd,  48,  51, 0 ),
-  V(  51, 0x04de,  50,  52, 0 ),
-  V(  52, 0x040f,  50,  53, 0 ),
-  V(  53, 0x0363,  51,  54, 0 ),
-  V(  54, 0x02d4,  52,  55, 0 ),
-  V(  55, 0x025c,  53,  56, 0 ),
-  V(  56, 0x01f8,  54,  57, 0 ),
-  V(  57, 0x01a4,  55,  58, 0 ),
-  V(  58, 0x0160,  56,  59, 0 ),
-  V(  59, 0x0125,  57,  60, 0 ),
-  V(  60, 0x00f6,  58,  61, 0 ),
-  V(  61, 0x00cb,  59,  62, 0 ),
-  V(  62, 0x00ab,  61,  63, 0 ),
-  V(  63, 0x008f,  61,  32, 0 ),
-  V(  64, 0x5b12,  65,  65, 1 ),
-  V(  65, 0x4d04,  80,  66, 0 ),
-  V(  66, 0x412c,  81,  67, 0 ),
-  V(  67, 0x37d8,  82,  68, 0 ),
-  V(  68, 0x2fe8,  83,  69, 0 ),
-  V(  69, 0x293c,  84,  70, 0 ),
-  V(  70, 0x2379,  86,  71, 0 ),
-  V(  71, 0x1edf,  87,  72, 0 ),
-  V(  72, 0x1aa9,  87,  73, 0 ),
-  V(  73, 0x174e,  72,  74, 0 ),
-  V(  74, 0x1424,  72,  75, 0 ),
-  V(  75, 0x119c,  74,  76, 0 ),
-  V(  76, 0x0f6b,  74,  77, 0 ),
-  V(  77, 0x0d51,  75,  78, 0 ),
-  V(  78, 0x0bb6,  77,  79, 0 ),
-  V(  79, 0x0a40,  77,  48, 0 ),
-  V(  80, 0x5832,  80,  81, 1 ),
-  V(  81, 0x4d1c,  88,  82, 0 ),
-  V(  82, 0x438e,  89,  83, 0 ),
-  V(  83, 0x3bdd,  90,  84, 0 ),
-  V(  84, 0x34ee,  91,  85, 0 ),
-  V(  85, 0x2eae,  92,  86, 0 ),
-  V(  86, 0x299a,  93,  87, 0 ),
-  V(  87, 0x2516,  86,  71, 0 ),
-  V(  88, 0x5570,  88,  89, 1 ),
-  V(  89, 0x4ca9,  95,  90, 0 ),
-  V(  90, 0x44d9,  96,  91, 0 ),
-  V(  91, 0x3e22,  97,  92, 0 ),
-  V(  92, 0x3824,  99,  93, 0 ),
-  V(  93, 0x32b4,  99,  94, 0 ),
-  V(  94, 0x2e17,  93,  86, 0 ),
-  V(  95, 0x56a8,  95,  96, 1 ),
-  V(  96, 0x4f46, 101,  97, 0 ),
-  V(  97, 0x47e5, 102,  98, 0 ),
-  V(  98, 0x41cf, 103,  99, 0 ),
-  V(  99, 0x3c3d, 104, 100, 0 ),
-  V( 100, 0x375e,  99,  93, 0 ),
-  V( 101, 0x5231, 105, 102, 0 ),
-  V( 102, 0x4c0f, 106, 103, 0 ),
-  V( 103, 0x4639, 107, 104, 0 ),
-  V( 104, 0x415e, 103,  99, 0 ),
-  V( 105, 0x5627, 105, 106, 1 ),
-  V( 106, 0x50e7, 108, 107, 0 ),
-  V( 107, 0x4b85, 109, 103, 0 ),
-  V( 108, 0x5597, 110, 109, 0 ),
-  V( 109, 0x504f, 111, 107, 0 ),
-  V( 110, 0x5a10, 110, 111, 1 ),
-  V( 111, 0x5522, 112, 109, 0 ),
-  V( 112, 0x59eb, 112, 111, 1 ),
-/*
- * This last entry is used for fixed probability estimate of 0.5
- * as recommended in Section 10.3 Table 5 of ITU-T Rec. T.851.
- */
-  V( 113, 0x5a1d, 113, 113, 0 )
-};
@@ -1,318 +0,0 @@
-/*
- * jcapimin.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1994-1998, Thomas G. Lane.
- * Modified 2003-2010 by Guido Vollbeding.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains application interface code for the compression half
- * of the JPEG library.  These are the "minimum" API routines that may be
- * needed in either the normal full-compression case or the transcoding-only
- * case.
- *
- * Most of the routines intended to be called directly by an application
- * are in this file or in jcapistd.c.  But also see jcparam.c for
- * parameter-setup helper routines, jcomapi.c for routines shared by
- * compression and decompression, and jctrans.c for the transcoding case.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jcmaster.h"
-
-
-/*
- * Initialization of a JPEG compression object.
- * The error manager must already be set up (in case memory manager fails).
- */
-
-GLOBAL(void)
-jpeg_CreateCompress(j_compress_ptr cinfo, int version, size_t structsize)
-{
-  int i;
-
-  /* Guard against version mismatches between library and caller. */
-  cinfo->mem = NULL;            /* so jpeg_destroy knows mem mgr not called */
-  if (version != JPEG_LIB_VERSION)
-    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);
-
-  /* For debugging purposes, we zero the whole master structure.
-   * But the application has already set the err pointer, and may have set
-   * client_data, so we have to save and restore those fields.
-   * Note: if application hasn't set client_data, tools like Purify may
-   * complain here.
-   */
-  {
-    struct jpeg_error_mgr *err = cinfo->err;
-    void *client_data = cinfo->client_data; /* ignore Purify complaint here */
-    memset(cinfo, 0, sizeof(struct jpeg_compress_struct));
-    cinfo->err = err;
-    cinfo->client_data = client_data;
-  }
-  cinfo->is_decompressor = FALSE;
-
-  /* Initialize a memory manager instance for this object */
-  jinit_memory_mgr((j_common_ptr)cinfo);
-
-  /* Zero out pointers to permanent structures. */
-  cinfo->progress = NULL;
-  cinfo->dest = NULL;
-
-  cinfo->comp_info = NULL;
-
-  for (i = 0; i < NUM_QUANT_TBLS; i++) {
-    cinfo->quant_tbl_ptrs[i] = NULL;
-#if JPEG_LIB_VERSION >= 70
-    cinfo->q_scale_factor[i] = 100;
-#endif
-  }
-
-  for (i = 0; i < NUM_HUFF_TBLS; i++) {
-    cinfo->dc_huff_tbl_ptrs[i] = NULL;
-    cinfo->ac_huff_tbl_ptrs[i] = NULL;
-  }
-
-#if JPEG_LIB_VERSION >= 80
-  /* 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;
-#endif
-
-  cinfo->script_space = NULL;
-
-  cinfo->input_gamma = 1.0;     /* in case application forgets */
-
-  cinfo->data_precision = BITS_IN_JSAMPLE;
-
-  /* OK, I'm ready */
-  cinfo->global_state = CSTATE_START;
-
-  /* The master struct is used to store extension parameters, so we allocate it
-   * here.
-   */
-  cinfo->master = (struct jpeg_comp_master *)
-      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
-                                  sizeof(my_comp_master));
-  memset(cinfo->master, 0, sizeof(my_comp_master));
-}
-
-
-/*
- * Destruction of a JPEG compression object
- */
-
-GLOBAL(void)
-jpeg_destroy_compress(j_compress_ptr cinfo)
-{
-  jpeg_destroy((j_common_ptr)cinfo); /* use common routine */
-}
-
-
-/*
- * Abort processing of a JPEG compression operation,
- * but don't destroy the object itself.
- */
-
-GLOBAL(void)
-jpeg_abort_compress(j_compress_ptr cinfo)
-{
-  jpeg_abort((j_common_ptr)cinfo); /* use common routine */
-}
-
-
-/*
- * Forcibly suppress or un-suppress all quantization and Huffman tables.
- * Marks all currently defined tables as already written (if suppress)
- * or not written (if !suppress).  This will control whether they get emitted
- * by a subsequent jpeg_start_compress call.
- *
- * This routine is exported for use by applications that want to produce
- * abbreviated JPEG datastreams.  It logically belongs in jcparam.c, but
- * since it is called by jpeg_start_compress, we put it here --- otherwise
- * jcparam.o would be linked whether the application used it or not.
- */
-
-GLOBAL(void)
-jpeg_suppress_tables(j_compress_ptr cinfo, boolean suppress)
-{
-  int i;
-  JQUANT_TBL *qtbl;
-  JHUFF_TBL *htbl;
-
-  for (i = 0; i < NUM_QUANT_TBLS; i++) {
-    if ((qtbl = cinfo->quant_tbl_ptrs[i]) != NULL)
-      qtbl->sent_table = suppress;
-  }
-
-  for (i = 0; i < NUM_HUFF_TBLS; i++) {
-    if ((htbl = cinfo->dc_huff_tbl_ptrs[i]) != NULL)
-      htbl->sent_table = suppress;
-    if ((htbl = cinfo->ac_huff_tbl_ptrs[i]) != NULL)
-      htbl->sent_table = suppress;
-  }
-}
-
-
-/*
- * Finish JPEG compression.
- *
- * If a multipass operating mode was selected, this may do a great deal of
- * work including most of the actual output.
- */
-
-GLOBAL(void)
-jpeg_finish_compress(j_compress_ptr cinfo)
-{
-  JDIMENSION iMCU_row;
-
-  if (cinfo->global_state == CSTATE_SCANNING ||
-      cinfo->global_state == CSTATE_RAW_OK) {
-    /* Terminate first pass */
-    if (cinfo->next_scanline < cinfo->image_height)
-      ERREXIT(cinfo, JERR_TOO_LITTLE_DATA);
-    (*cinfo->master->finish_pass) (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) {
-    (*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);
-      }
-      /* We bypass the main controller and invoke coef controller directly;
-       * all work is being done from the coefficient buffer.
-       */
-      if (cinfo->data_precision == 16) {
-#ifdef C_LOSSLESS_SUPPORTED
-        if (!(*cinfo->coef->compress_data_16) (cinfo, (J16SAMPIMAGE)NULL))
-          ERREXIT(cinfo, JERR_CANT_SUSPEND);
-#else
-        ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-#endif
-      } else if (cinfo->data_precision == 12) {
-        if (!(*cinfo->coef->compress_data_12) (cinfo, (J12SAMPIMAGE)NULL))
-          ERREXIT(cinfo, JERR_CANT_SUSPEND);
-      } else {
-        if (!(*cinfo->coef->compress_data) (cinfo, (JSAMPIMAGE)NULL))
-          ERREXIT(cinfo, JERR_CANT_SUSPEND);
-      }
-    }
-    (*cinfo->master->finish_pass) (cinfo);
-  }
-  /* Write EOI, do final cleanup */
-  (*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);
-}
-
-
-/*
- * Write a special marker.
- * This is only recommended for writing COM or APPn markers.
- * Must be called after jpeg_start_compress() and before
- * first call to jpeg_write_scanlines() or jpeg_write_raw_data().
- */
-
-GLOBAL(void)
-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);
-
-  if (cinfo->next_scanline != 0 ||
-      (cinfo->global_state != CSTATE_SCANNING &&
-       cinfo->global_state != CSTATE_RAW_OK &&
-       cinfo->global_state != CSTATE_WRCOEFS))
-    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
-
-  (*cinfo->marker->write_marker_header) (cinfo, marker, datalen);
-  write_marker_byte = cinfo->marker->write_marker_byte; /* copy for speed */
-  while (datalen--) {
-    (*write_marker_byte) (cinfo, *dataptr);
-    dataptr++;
-  }
-}
-
-/* Same, but piecemeal. */
-
-GLOBAL(void)
-jpeg_write_m_header(j_compress_ptr cinfo, int marker, unsigned int datalen)
-{
-  if (cinfo->next_scanline != 0 ||
-      (cinfo->global_state != CSTATE_SCANNING &&
-       cinfo->global_state != CSTATE_RAW_OK &&
-       cinfo->global_state != CSTATE_WRCOEFS))
-    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
-
-  (*cinfo->marker->write_marker_header) (cinfo, marker, datalen);
-}
-
-GLOBAL(void)
-jpeg_write_m_byte(j_compress_ptr cinfo, int val)
-{
-  (*cinfo->marker->write_marker_byte) (cinfo, val);
-}
-
-
-/*
- * Alternate compression function: just write an abbreviated table file.
- * Before calling this, all parameters and a data destination must be set up.
- *
- * To produce a pair of files containing abbreviated tables and abbreviated
- * image data, one would proceed as follows:
- *
- *              initialize JPEG object
- *              set JPEG parameters
- *              set destination to table file
- *              jpeg_write_tables(cinfo);
- *              set destination to image file
- *              jpeg_start_compress(cinfo, FALSE);
- *              write data...
- *              jpeg_finish_compress(cinfo);
- *
- * jpeg_write_tables has the side effect of marking all tables written
- * (same as jpeg_suppress_tables(..., TRUE)).  Thus a subsequent start_compress
- * will not re-emit the tables unless it is passed write_all_tables=TRUE.
- */
-
-GLOBAL(void)
-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->dest->init_destination) (cinfo);
-  /* Initialize the marker writer ... bit of a crock to do it here. */
-  jinit_marker_writer(cinfo);
-  /* Write them tables! */
-  (*cinfo->marker->write_tables_only) (cinfo);
-  /* And clean up. */
-  (*cinfo->dest->term_destination) (cinfo);
-  /*
-   * In library releases up through v6a, we called jpeg_abort() here to free
-   * any working memory allocated by the destination manager and marker
-   * writer.  Some applications had a problem with that: they allocated space
-   * of their own from the library memory manager, and didn't want it to go
-   * away during write_tables.  So now we do nothing.  This will cause a
-   * memory leak if an app calls write_tables repeatedly without doing a full
-   * compression cycle or otherwise resetting the JPEG object.  However, that
-   * seems less bad than unexpectedly freeing memory in the normal case.
-   * An app that prefers the old behavior can call jpeg_abort for itself after
-   * each call to jpeg_write_tables().
-   */
-}
@@ -1,187 +0,0 @@
-/*
- * jcapistd.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1994-1996, Thomas G. Lane.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains application interface code for the compression half
- * of the JPEG library.  These are the "standard" API routines that are
- * used in the normal full-compression case.  They are not used by a
- * transcoding-only application.  Note that if an application links in
- * jpeg_start_compress, it will end up linking in the entire compressor.
- * We thus must separate this file from jcapimin.c to avoid linking the
- * whole compression library into a transcoder.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jsamplecomp.h"
-
-
-#if BITS_IN_JSAMPLE == 8
-
-/*
- * Compression initialization.
- * Before calling this, all parameters and a data destination must be set up.
- *
- * We require a write_all_tables parameter as a failsafe check when writing
- * multiple datastreams from the same compression object.  Since prior runs
- * will have left all the tables marked sent_table=TRUE, a subsequent run
- * would emit an abbreviated stream (no tables) by default.  This may be what
- * is wanted, but for safety's sake it should not be the default behavior:
- * programmers should have to make a deliberate choice to emit abbreviated
- * images.  Therefore the documentation and examples should encourage people
- * to pass write_all_tables=TRUE; then it will take active thought to do the
- * wrong thing.
- */
-
-GLOBAL(void)
-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);
-
-  if (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->dest->init_destination) (cinfo);
-  /* Perform master selection of active modules */
-  jinit_compress_master(cinfo);
-  /* Set up for the first pass */
-  (*cinfo->master->prepare_for_pass) (cinfo);
-  /* Ready for application to drive first pass through _jpeg_write_scanlines
-   * or _jpeg_write_raw_data.
-   */
-  cinfo->next_scanline = 0;
-  cinfo->global_state = (cinfo->raw_data_in ? CSTATE_RAW_OK : CSTATE_SCANNING);
-}
-
-#endif
-
-
-/*
- * Write some scanlines of data to the JPEG compressor.
- *
- * The return value will be the number of lines actually written.
- * This should be less than the supplied num_lines only in case that
- * the data destination module has requested suspension of the compressor,
- * or if more than image_height scanlines are passed in.
- *
- * Note: we warn about excess calls to _jpeg_write_scanlines() since
- * this likely signals an application programmer error.  However,
- * excess scanlines passed in the last valid call are *silently* ignored,
- * so that the application need not adjust num_lines for end-of-image
- * when using a multiple-scanline buffer.
- */
-
-GLOBAL(JDIMENSION)
-_jpeg_write_scanlines(j_compress_ptr cinfo, _JSAMPARRAY scanlines,
-                      JDIMENSION num_lines)
-{
-#if BITS_IN_JSAMPLE != 16 || defined(C_LOSSLESS_SUPPORTED)
-  JDIMENSION row_ctr, rows_left;
-
-  if (cinfo->data_precision != BITS_IN_JSAMPLE)
-    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-
-  if (cinfo->global_state != CSTATE_SCANNING)
-    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
-  if (cinfo->next_scanline >= cinfo->image_height)
-    WARNMS(cinfo, JWRN_TOO_MUCH_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);
-  }
-
-  /* Give master control module another chance if this is first call to
-   * _jpeg_write_scanlines.  This lets output of the frame/scan headers be
-   * delayed so that application can write COM, etc, markers between
-   * jpeg_start_compress and _jpeg_write_scanlines.
-   */
-  if (cinfo->master->call_pass_startup)
-    (*cinfo->master->pass_startup) (cinfo);
-
-  /* Ignore any extra scanlines at bottom of image. */
-  rows_left = cinfo->image_height - cinfo->next_scanline;
-  if (num_lines > rows_left)
-    num_lines = rows_left;
-
-  row_ctr = 0;
-  (*cinfo->main->_process_data) (cinfo, scanlines, &row_ctr, num_lines);
-  cinfo->next_scanline += row_ctr;
-  return row_ctr;
-#else
-  ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-  return 0;
-#endif
-}
-
-
-#if BITS_IN_JSAMPLE != 16
-
-/*
- * Alternate entry point to write raw data.
- * Processes exactly one iMCU row per call, unless suspended.
- */
-
-GLOBAL(JDIMENSION)
-_jpeg_write_raw_data(j_compress_ptr cinfo, _JSAMPIMAGE data,
-                     JDIMENSION num_lines)
-{
-  JDIMENSION lines_per_iMCU_row;
-
-  if (cinfo->data_precision != BITS_IN_JSAMPLE)
-    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-
-  if (cinfo->master->lossless)
-    ERREXIT(cinfo, JERR_NOTIMPL);
-
-  if (cinfo->global_state != CSTATE_RAW_OK)
-    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
-  if (cinfo->next_scanline >= cinfo->image_height) {
-    WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
-    return 0;
-  }
-
-  /* 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);
-  }
-
-  /* Give master control module another chance if this is first call to
-   * _jpeg_write_raw_data.  This lets output of the frame/scan headers be
-   * delayed so that application can write COM, etc, markers between
-   * jpeg_start_compress and _jpeg_write_raw_data.
-   */
-  if (cinfo->master->call_pass_startup)
-    (*cinfo->master->pass_startup) (cinfo);
-
-  /* Verify that at least one iMCU row has been passed. */
-  lines_per_iMCU_row = cinfo->max_v_samp_factor * DCTSIZE;
-  if (num_lines < lines_per_iMCU_row)
-    ERREXIT(cinfo, JERR_BUFFER_SIZE);
-
-  /* Directly compress the row. */
-  if (!(*cinfo->coef->_compress_data) (cinfo, data)) {
-    /* If compressor did not consume the whole row, suspend processing. */
-    return 0;
-  }
-
-  /* OK, we processed one iMCU row. */
-  cinfo->next_scanline += lines_per_iMCU_row;
-  return lines_per_iMCU_row;
-}
-
-#endif /* BITS_IN_JSAMPLE != 16 */
@@ -1,932 +0,0 @@
-/*
- * jcarith.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Developed 1997-2009 by Guido Vollbeding.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2015, 2018, 2021-2022, 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).
- *
- * 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
-#include "jinclude.h"
-#include "jpeglib.h"
-
-
-/* Expanded entropy encoder object for arithmetic encoding. */
-
-typedef struct {
-  struct jpeg_entropy_encoder pub; /* public fields */
-
-  JLONG c; /* C register, base of coding interval, layout as in sec. D.1.3 */
-  JLONG a;               /* A register, normalized size of coding interval */
-  JLONG sc;        /* counter for stacked 0xFF values which might overflow */
-  JLONG zc;          /* counter for pending 0x00 output values which might *
-                          * be discarded at the end ("Pacman" termination) */
-  int ct;  /* bit shift counter, determines when next byte will be written */
-  int buffer;                /* buffer for most recent output byte != 0xFF */
-
-  int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
-  int dc_context[MAX_COMPS_IN_SCAN]; /* context index for DC conditioning */
-
-  unsigned int restarts_to_go;  /* MCUs left in this restart interval */
-  int next_restart_num;         /* next restart number to write (0-7) */
-
-  /* Pointers to statistics areas (these workspaces have image lifespan) */
-  unsigned char *dc_stats[NUM_ARITH_TBLS];
-  unsigned char *ac_stats[NUM_ARITH_TBLS];
-
-  /* Statistics bin for coding with fixed probability 0.5 */
-  unsigned char fixed_bin[4];
-} arith_entropy_encoder;
-
-typedef arith_entropy_encoder *arith_entropy_ptr;
-
-/* The following two definitions specify the allocation chunk size
- * for the statistics area.
- * According to sections F.1.4.4.1.3 and F.1.4.4.2, we need at least
- * 49 statistics bins for DC, and 245 statistics bins for AC coding.
- *
- * We use a compact representation with 1 byte per statistics bin,
- * thus the numbers directly represent byte sizes.
- * This 1 byte per statistics bin contains the meaning of the MPS
- * (more probable symbol) in the highest bit (mask 0x80), and the
- * index into the probability estimation state machine table
- * in the lower bits (mask 0x7F).
- */
-
-#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
- * for spectral selection progressive coding in section G.1.3.2
- * of the spec (Kx = Kmin + SRL (8 + Se - Kmin) 4).
- * Although the spec and P&M authors claim that this "has proven
- * to give good results for 8 bit precision samples", I'm not
- * convinced yet that this is really beneficial.
- * Early tests gave only very marginal compression enhancements
- * (a few - around 5 or so - bytes even for very large files),
- * which would turn out rather negative if we'd suppress the
- * DAC (Define Arithmetic Conditioning) marker segments for
- * the default parameters in the future.
- * Note that currently the marker writing module emits 12-byte
- * DAC segments for a full-component scan in a color image.
- * This is not worth worrying about IMHO. However, since the
- * spec defines the default values to be used if the tables
- * are omitted (unlike Huffman tables, which are required
- * anyway), one might optimize this behaviour in the future,
- * and then it would be disadvantageous to use custom tables if
- * they don't provide sufficient gain to exceed the DAC size.
- *
- * On the other hand, I'd consider it as a reasonable result
- * that the conditioning has no significant influence on the
- * compression performance. This means that the basic
- * statistical model is already rather stable.
- *
- * Thus, at the moment, we use the default conditioning values
- * anyway, and do not use the custom formula.
- *
-#define CALCULATE_SPECTRAL_CONDITIONING
- */
-
-/* IRIGHT_SHIFT is like RIGHT_SHIFT, but works on int rather than JLONG.
- * We assume that int right shift is unsigned if JLONG right shift is,
- * which should be safe.
- */
-
-#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)))
-#else
-#define ISHIFT_TEMPS
-#define IRIGHT_SHIFT(x, shft)   ((x) >> (shft))
-#endif
-
-
-LOCAL(void)
-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;
-  if (--dest->free_in_buffer == 0)
-    if (!(*dest->empty_output_buffer) (cinfo))
-      ERREXIT(cinfo, JERR_CANT_SUSPEND);
-}
-
-
-/*
- * Finish up at the end of an arithmetic-compressed scan.
- */
-
-METHODDEF(void)
-finish_pass(j_compress_ptr cinfo)
-{
-  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)
-    e->c = temp + 0x8000L;
-  else
-    e->c = temp;
-  /* Send remaining bytes to output */
-  e->c <<= e->ct;
-  if (e->c & 0xF8000000UL) {
-    /* One final overflow has to be handled */
-    if (e->buffer >= 0) {
-      if (e->zc)
-        do emit_byte(0x00, cinfo);
-        while (--e->zc);
-      emit_byte(e->buffer + 1, cinfo);
-      if (e->buffer + 1 == 0xFF)
-        emit_byte(0x00, cinfo);
-    }
-    e->zc += e->sc;  /* carry-over converts stacked 0xFF bytes to 0x00 */
-    e->sc = 0;
-  } else {
-    if (e->buffer == 0)
-      ++e->zc;
-    else if (e->buffer >= 0) {
-      if (e->zc)
-        do emit_byte(0x00, cinfo);
-        while (--e->zc);
-      emit_byte(e->buffer, cinfo);
-    }
-    if (e->sc) {
-      if (e->zc)
-        do emit_byte(0x00, cinfo);
-        while (--e->zc);
-      do {
-        emit_byte(0xFF, cinfo);
-        emit_byte(0x00, cinfo);
-      } while (--e->sc);
-    }
-  }
-  /* Output final bytes only if they are not 0x00 */
-  if (e->c & 0x7FFF800L) {
-    if (e->zc)  /* output final pending zero bytes */
-      do emit_byte(0x00, cinfo);
-      while (--e->zc);
-    emit_byte((e->c >> 19) & 0xFF, cinfo);
-    if (((e->c >> 19) & 0xFF) == 0xFF)
-      emit_byte(0x00, cinfo);
-    if (e->c & 0x7F800L) {
-      emit_byte((e->c >> 11) & 0xFF, cinfo);
-      if (((e->c >> 11) & 0xFF) == 0xFF)
-        emit_byte(0x00, cinfo);
-    }
-  }
-}
-
-
-/*
- * The core arithmetic encoding routine (common in JPEG and JBIG).
- * This needs to go as fast as possible.
- * Machine-dependent optimization facilities
- * are not utilized in this portable implementation.
- * However, this code should be fairly efficient and
- * may be a good base for further optimizations anyway.
- *
- * Parameter 'val' to be encoded may be 0 or 1 (binary decision).
- *
- * Note: I've added full "Pacman" termination support to the
- * byte output routines, which is equivalent to the optional
- * Discard_final_zeros procedure (Figure D.15) in the spec.
- * Thus, we always produce the shortest possible output
- * stream compliant to the spec (no trailing zero bytes,
- * except for FF stuffing).
- *
- * I've also introduced a new scheme for accessing
- * the probability estimation state machine table,
- * derived from Markus Kuhn's JBIG implementation.
- */
-
-LOCAL(void)
-arith_encode(j_compress_ptr cinfo, unsigned char *st, int val)
-{
-  register arith_entropy_ptr e = (arith_entropy_ptr)cinfo->entropy;
-  register unsigned char nl, nm;
-  register JLONG qe, temp;
-  register int sv;
-
-  /* Fetch values from our compact representation of Table D.2:
-   * Qe values and probability estimation state machine
-   */
-  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 */
-
-  /* Encode & estimation procedures per sections D.1.4 & D.1.5 */
-  e->a -= qe;
-  if (val != (sv >> 7)) {
-    /* Encode the less probable symbol */
-    if (e->a >= qe) {
-      /* If the interval size (qe) for the less probable symbol (LPS)
-       * is larger than the interval size for the MPS, then exchange
-       * the two symbols for coding efficiency, otherwise code the LPS
-       * as usual: */
-      e->c += e->a;
-      e->a = qe;
-    }
-    *st = (sv & 0x80) ^ nl;     /* Estimate_after_LPS */
-  } else {
-    /* Encode the more probable symbol */
-    if (e->a >= 0x8000L)
-      return;  /* A >= 0x8000 -> ready, no renormalization required */
-    if (e->a < qe) {
-      /* If the interval size (qe) for the less probable symbol (LPS)
-       * is larger than the interval size for the MPS, then exchange
-       * the two symbols for coding efficiency: */
-      e->c += e->a;
-      e->a = qe;
-    }
-    *st = (sv & 0x80) ^ nm;     /* Estimate_after_MPS */
-  }
-
-  /* Renormalization & data output per section D.1.6 */
-  do {
-    e->a <<= 1;
-    e->c <<= 1;
-    if (--e->ct == 0) {
-      /* Another byte is ready for output */
-      temp = e->c >> 19;
-      if (temp > 0xFF) {
-        /* Handle overflow over all stacked 0xFF bytes */
-        if (e->buffer >= 0) {
-          if (e->zc)
-            do emit_byte(0x00, cinfo);
-            while (--e->zc);
-          emit_byte(e->buffer + 1, cinfo);
-          if (e->buffer + 1 == 0xFF)
-            emit_byte(0x00, cinfo);
-        }
-        e->zc += e->sc;  /* carry-over converts stacked 0xFF bytes to 0x00 */
-        e->sc = 0;
-        /* Note: The 3 spacer bits in the C register guarantee
-         * that the new buffer byte can't be 0xFF here
-         * (see page 160 in the P&M JPEG book). */
-        e->buffer = temp & 0xFF;  /* new output byte, might overflow later */
-      } else if (temp == 0xFF) {
-        ++e->sc;  /* stack 0xFF byte (which might overflow later) */
-      } else {
-        /* Output all stacked 0xFF bytes, they will not overflow any more */
-        if (e->buffer == 0)
-          ++e->zc;
-        else if (e->buffer >= 0) {
-          if (e->zc)
-            do emit_byte(0x00, cinfo);
-            while (--e->zc);
-          emit_byte(e->buffer, cinfo);
-        }
-        if (e->sc) {
-          if (e->zc)
-            do emit_byte(0x00, cinfo);
-            while (--e->zc);
-          do {
-            emit_byte(0xFF, cinfo);
-            emit_byte(0x00, cinfo);
-          } while (--e->sc);
-        }
-        e->buffer = temp & 0xFF;  /* new output byte (can still overflow) */
-      }
-      e->c &= 0x7FFFFL;
-      e->ct += 8;
-    }
-  } while (e->a < 0x8000L);
-}
-
-
-/*
- * Emit a restart marker & resynchronize predictions.
- */
-
-LOCAL(void)
-emit_restart(j_compress_ptr cinfo, int restart_num)
-{
-  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
-  int ci;
-  jpeg_component_info *compptr;
-
-  finish_pass(cinfo);
-
-  emit_byte(0xFF, cinfo);
-  emit_byte(JPEG_RST0 + restart_num, cinfo);
-
-  /* Re-initialize statistics areas */
-  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
-    compptr = cinfo->cur_comp_info[ci];
-    /* DC needs no table for refinement scan */
-    if (cinfo->progressive_mode == 0 || (cinfo->Ss == 0 && cinfo->Ah == 0)) {
-      memset(entropy->dc_stats[compptr->dc_tbl_no], 0, DC_STAT_BINS);
-      /* Reset DC predictions to 0 */
-      entropy->last_dc_val[ci] = 0;
-      entropy->dc_context[ci] = 0;
-    }
-    /* AC needs no table when not present */
-    if (cinfo->progressive_mode == 0 || cinfo->Se) {
-      memset(entropy->ac_stats[compptr->ac_tbl_no], 0, AC_STAT_BINS);
-    }
-  }
-
-  /* Reset arithmetic encoding variables */
-  entropy->c = 0;
-  entropy->a = 0x10000L;
-  entropy->sc = 0;
-  entropy->zc = 0;
-  entropy->ct = 11;
-  entropy->buffer = -1;  /* empty */
-}
-
-
-/*
- * MCU encoding for DC initial scan (either spectral selection,
- * or first pass of successive approximation).
- */
-
-METHODDEF(boolean)
-encode_mcu_DC_first(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
-{
-  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
-  JBLOCKROW block;
-  unsigned char *st;
-  int blkn, ci, tbl;
-  int v, v2, m;
-  ISHIFT_TEMPS
-
-  /* Emit restart marker if needed */
-  if (cinfo->restart_interval) {
-    if (entropy->restarts_to_go == 0) {
-      emit_restart(cinfo, entropy->next_restart_num);
-      entropy->restarts_to_go = cinfo->restart_interval;
-      entropy->next_restart_num++;
-      entropy->next_restart_num &= 7;
-    }
-    entropy->restarts_to_go--;
-  }
-
-  /* Encode the MCU data blocks */
-  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
-    block = MCU_data[blkn];
-    ci = cinfo->MCU_membership[blkn];
-    tbl = cinfo->cur_comp_info[ci]->dc_tbl_no;
-
-    /* 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);
-
-    /* Sections F.1.4.1 & F.1.4.4.1: Encoding of DC coefficients */
-
-    /* Table F.4: Point to statistics bin S0 for DC coefficient coding */
-    st = entropy->dc_stats[tbl] + entropy->dc_context[ci];
-
-    /* Figure F.4: Encode_DC_DIFF */
-    if ((v = m - entropy->last_dc_val[ci]) == 0) {
-      arith_encode(cinfo, st, 0);
-      entropy->dc_context[ci] = 0;      /* zero diff category */
-    } else {
-      entropy->last_dc_val[ci] = m;
-      arith_encode(cinfo, st, 1);
-      /* Figure F.6: Encoding nonzero value v */
-      /* Figure F.7: Encoding the sign of v */
-      if (v > 0) {
-        arith_encode(cinfo, st + 1, 0); /* Table F.4: SS = S0 + 1 */
-        st += 2;                        /* Table F.4: SP = S0 + 2 */
-        entropy->dc_context[ci] = 4;    /* small positive diff category */
-      } else {
-        v = -v;
-        arith_encode(cinfo, st + 1, 1); /* Table F.4: SS = S0 + 1 */
-        st += 3;                        /* Table F.4: SN = S0 + 3 */
-        entropy->dc_context[ci] = 8;    /* small negative diff category */
-      }
-      /* Figure F.8: Encoding the magnitude category of v */
-      m = 0;
-      if (v -= 1) {
-        arith_encode(cinfo, st, 1);
-        m = 1;
-        v2 = v;
-        st = entropy->dc_stats[tbl] + 20; /* Table F.4: X1 = 20 */
-        while (v2 >>= 1) {
-          arith_encode(cinfo, st, 1);
-          m <<= 1;
-          st += 1;
-        }
-      }
-      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))
-        entropy->dc_context[ci] = 0;    /* zero diff category */
-      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;
-      while (m >>= 1)
-        arith_encode(cinfo, st, (m & v) ? 1 : 0);
-    }
-  }
-
-  return TRUE;
-}
-
-
-/*
- * MCU encoding for AC initial scan (either spectral selection,
- * or first pass of successive approximation).
- */
-
-METHODDEF(boolean)
-encode_mcu_AC_first(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
-{
-  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
-  JBLOCKROW block;
-  unsigned char *st;
-  int tbl, k, ke;
-  int v, v2, m;
-
-  /* Emit restart marker if needed */
-  if (cinfo->restart_interval) {
-    if (entropy->restarts_to_go == 0) {
-      emit_restart(cinfo, entropy->next_restart_num);
-      entropy->restarts_to_go = cinfo->restart_interval;
-      entropy->next_restart_num++;
-      entropy->next_restart_num &= 7;
-    }
-    entropy->restarts_to_go--;
-  }
-
-  /* Encode the MCU data block */
-  block = MCU_data[0];
-  tbl = cinfo->cur_comp_info[0]->ac_tbl_no;
-
-  /* Sections F.1.4.2 & F.1.4.4.2: Encoding of AC coefficients */
-
-  /* Establish EOB (end-of-block) index */
-  for (ke = cinfo->Se; ke > 0; ke--)
-    /* 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 ((v = (*block)[jpeg_natural_order[ke]]) >= 0) {
-      if (v >>= cinfo->Al) break;
-    } else {
-      v = -v;
-      if (v >>= cinfo->Al) break;
-    }
-
-  /* Figure F.5: Encode_AC_Coefficients */
-  for (k = cinfo->Ss; k <= ke; k++) {
-    st = entropy->ac_stats[tbl] + 3 * (k - 1);
-    arith_encode(cinfo, st, 0);         /* EOB decision */
-    for (;;) {
-      if ((v = (*block)[jpeg_natural_order[k]]) >= 0) {
-        if (v >>= cinfo->Al) {
-          arith_encode(cinfo, st + 1, 1);
-          arith_encode(cinfo, entropy->fixed_bin, 0);
-          break;
-        }
-      } else {
-        v = -v;
-        if (v >>= cinfo->Al) {
-          arith_encode(cinfo, st + 1, 1);
-          arith_encode(cinfo, entropy->fixed_bin, 1);
-          break;
-        }
-      }
-      arith_encode(cinfo, st + 1, 0);  st += 3;  k++;
-    }
-    st += 2;
-    /* Figure F.8: Encoding the magnitude category of v */
-    m = 0;
-    if (v -= 1) {
-      arith_encode(cinfo, st, 1);
-      m = 1;
-      v2 = v;
-      if (v2 >>= 1) {
-        arith_encode(cinfo, st, 1);
-        m <<= 1;
-        st = entropy->ac_stats[tbl] +
-             (k <= cinfo->arith_ac_K[tbl] ? 189 : 217);
-        while (v2 >>= 1) {
-          arith_encode(cinfo, st, 1);
-          m <<= 1;
-          st += 1;
-        }
-      }
-    }
-    arith_encode(cinfo, st, 0);
-    /* Figure F.9: Encoding the magnitude bit pattern of v */
-    st += 14;
-    while (m >>= 1)
-      arith_encode(cinfo, st, (m & v) ? 1 : 0);
-  }
-  /* Encode EOB decision only if k <= cinfo->Se */
-  if (k <= cinfo->Se) {
-    st = entropy->ac_stats[tbl] + 3 * (k - 1);
-    arith_encode(cinfo, st, 1);
-  }
-
-  return TRUE;
-}
-
-
-/*
- * MCU encoding for DC successive approximation refinement scan.
- */
-
-METHODDEF(boolean)
-encode_mcu_DC_refine(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
-{
-  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
-  unsigned char *st;
-  int Al, blkn;
-
-  /* Emit restart marker if needed */
-  if (cinfo->restart_interval) {
-    if (entropy->restarts_to_go == 0) {
-      emit_restart(cinfo, entropy->next_restart_num);
-      entropy->restarts_to_go = cinfo->restart_interval;
-      entropy->next_restart_num++;
-      entropy->next_restart_num &= 7;
-    }
-    entropy->restarts_to_go--;
-  }
-
-  st = entropy->fixed_bin;      /* use fixed probability estimation */
-  Al = cinfo->Al;
-
-  /* Encode the MCU data blocks */
-  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
-    /* We simply emit the Al'th bit of the DC coefficient value. */
-    arith_encode(cinfo, st, (MCU_data[blkn][0][0] >> Al) & 1);
-  }
-
-  return TRUE;
-}
-
-
-/*
- * MCU encoding for AC successive approximation refinement scan.
- */
-
-METHODDEF(boolean)
-encode_mcu_AC_refine(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
-{
-  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
-  JBLOCKROW block;
-  unsigned char *st;
-  int tbl, k, ke, kex;
-  int v;
-
-  /* Emit restart marker if needed */
-  if (cinfo->restart_interval) {
-    if (entropy->restarts_to_go == 0) {
-      emit_restart(cinfo, entropy->next_restart_num);
-      entropy->restarts_to_go = cinfo->restart_interval;
-      entropy->next_restart_num++;
-      entropy->next_restart_num &= 7;
-    }
-    entropy->restarts_to_go--;
-  }
-
-  /* Encode the MCU data block */
-  block = MCU_data[0];
-  tbl = cinfo->cur_comp_info[0]->ac_tbl_no;
-
-  /* Section G.1.3.3: Encoding of AC coefficients */
-
-  /* Establish EOB (end-of-block) index */
-  for (ke = cinfo->Se; ke > 0; ke--)
-    /* 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 ((v = (*block)[jpeg_natural_order[ke]]) >= 0) {
-      if (v >>= cinfo->Al) break;
-    } else {
-      v = -v;
-      if (v >>= cinfo->Al) break;
-    }
-
-  /* Establish EOBx (previous stage end-of-block) index */
-  for (kex = ke; kex > 0; kex--)
-    if ((v = (*block)[jpeg_natural_order[kex]]) >= 0) {
-      if (v >>= cinfo->Ah) break;
-    } else {
-      v = -v;
-      if (v >>= cinfo->Ah) break;
-    }
-
-  /* Figure G.10: Encode_AC_Coefficients_SA */
-  for (k = cinfo->Ss; k <= ke; k++) {
-    st = entropy->ac_stats[tbl] + 3 * (k - 1);
-    if (k > kex)
-      arith_encode(cinfo, st, 0);       /* EOB decision */
-    for (;;) {
-      if ((v = (*block)[jpeg_natural_order[k]]) >= 0) {
-        if (v >>= cinfo->Al) {
-          if (v >> 1)                   /* previously nonzero coef */
-            arith_encode(cinfo, st + 2, (v & 1));
-          else {                        /* newly nonzero coef */
-            arith_encode(cinfo, st + 1, 1);
-            arith_encode(cinfo, entropy->fixed_bin, 0);
-          }
-          break;
-        }
-      } else {
-        v = -v;
-        if (v >>= cinfo->Al) {
-          if (v >> 1)                   /* previously nonzero coef */
-            arith_encode(cinfo, st + 2, (v & 1));
-          else {                        /* newly nonzero coef */
-            arith_encode(cinfo, st + 1, 1);
-            arith_encode(cinfo, entropy->fixed_bin, 1);
-          }
-          break;
-        }
-      }
-      arith_encode(cinfo, st + 1, 0);  st += 3;  k++;
-    }
-  }
-  /* Encode EOB decision only if k <= cinfo->Se */
-  if (k <= cinfo->Se) {
-    st = entropy->ac_stats[tbl] + 3 * (k - 1);
-    arith_encode(cinfo, st, 1);
-  }
-
-  return TRUE;
-}
-
-
-/*
- * Encode and output one MCU's worth of arithmetic-compressed coefficients.
- */
-
-METHODDEF(boolean)
-encode_mcu(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
-{
-  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
-  jpeg_component_info *compptr;
-  JBLOCKROW block;
-  unsigned char *st;
-  int blkn, ci, tbl, k, ke;
-  int v, v2, m;
-
-  /* Emit restart marker if needed */
-  if (cinfo->restart_interval) {
-    if (entropy->restarts_to_go == 0) {
-      emit_restart(cinfo, entropy->next_restart_num);
-      entropy->restarts_to_go = cinfo->restart_interval;
-      entropy->next_restart_num++;
-      entropy->next_restart_num &= 7;
-    }
-    entropy->restarts_to_go--;
-  }
-
-  /* Encode the MCU data blocks */
-  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
-    block = MCU_data[blkn];
-    ci = cinfo->MCU_membership[blkn];
-    compptr = cinfo->cur_comp_info[ci];
-
-    /* Sections F.1.4.1 & F.1.4.4.1: Encoding of DC coefficients */
-
-    tbl = compptr->dc_tbl_no;
-
-    /* Table F.4: Point to statistics bin S0 for DC coefficient coding */
-    st = entropy->dc_stats[tbl] + entropy->dc_context[ci];
-
-    /* Figure F.4: Encode_DC_DIFF */
-    if ((v = (*block)[0] - entropy->last_dc_val[ci]) == 0) {
-      arith_encode(cinfo, st, 0);
-      entropy->dc_context[ci] = 0;      /* zero diff category */
-    } else {
-      entropy->last_dc_val[ci] = (*block)[0];
-      arith_encode(cinfo, st, 1);
-      /* Figure F.6: Encoding nonzero value v */
-      /* Figure F.7: Encoding the sign of v */
-      if (v > 0) {
-        arith_encode(cinfo, st + 1, 0); /* Table F.4: SS = S0 + 1 */
-        st += 2;                        /* Table F.4: SP = S0 + 2 */
-        entropy->dc_context[ci] = 4;    /* small positive diff category */
-      } else {
-        v = -v;
-        arith_encode(cinfo, st + 1, 1); /* Table F.4: SS = S0 + 1 */
-        st += 3;                        /* Table F.4: SN = S0 + 3 */
-        entropy->dc_context[ci] = 8;    /* small negative diff category */
-      }
-      /* Figure F.8: Encoding the magnitude category of v */
-      m = 0;
-      if (v -= 1) {
-        arith_encode(cinfo, st, 1);
-        m = 1;
-        v2 = v;
-        st = entropy->dc_stats[tbl] + 20; /* Table F.4: X1 = 20 */
-        while (v2 >>= 1) {
-          arith_encode(cinfo, st, 1);
-          m <<= 1;
-          st += 1;
-        }
-      }
-      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))
-        entropy->dc_context[ci] = 0;    /* zero diff category */
-      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;
-      while (m >>= 1)
-        arith_encode(cinfo, st, (m & v) ? 1 : 0);
-    }
-
-    /* Sections F.1.4.2 & F.1.4.4.2: Encoding of AC coefficients */
-
-    tbl = compptr->ac_tbl_no;
-
-    /* Establish EOB (end-of-block) index */
-    for (ke = DCTSIZE2 - 1; ke > 0; ke--)
-      if ((*block)[jpeg_natural_order[ke]]) break;
-
-    /* Figure F.5: Encode_AC_Coefficients */
-    for (k = 1; k <= ke; k++) {
-      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, 1);
-      /* Figure F.6: Encoding nonzero value v */
-      /* Figure F.7: Encoding the sign of v */
-      if (v > 0) {
-        arith_encode(cinfo, entropy->fixed_bin, 0);
-      } else {
-        v = -v;
-        arith_encode(cinfo, entropy->fixed_bin, 1);
-      }
-      st += 2;
-      /* Figure F.8: Encoding the magnitude category of v */
-      m = 0;
-      if (v -= 1) {
-        arith_encode(cinfo, st, 1);
-        m = 1;
-        v2 = v;
-        if (v2 >>= 1) {
-          arith_encode(cinfo, st, 1);
-          m <<= 1;
-          st = entropy->ac_stats[tbl] +
-               (k <= cinfo->arith_ac_K[tbl] ? 189 : 217);
-          while (v2 >>= 1) {
-            arith_encode(cinfo, st, 1);
-            m <<= 1;
-            st += 1;
-          }
-        }
-      }
-      arith_encode(cinfo, st, 0);
-      /* Figure F.9: Encoding the magnitude bit pattern of v */
-      st += 14;
-      while (m >>= 1)
-        arith_encode(cinfo, st, (m & v) ? 1 : 0);
-    }
-    /* Encode EOB decision only if k <= DCTSIZE2 - 1 */
-    if (k <= DCTSIZE2 - 1) {
-      st = entropy->ac_stats[tbl] + 3 * (k - 1);
-      arith_encode(cinfo, st, 1);
-    }
-  }
-
-  return TRUE;
-}
-
-
-/*
- * Initialize for an arithmetic-compressed scan.
- */
-
-METHODDEF(void)
-start_pass(j_compress_ptr cinfo, boolean gather_statistics)
-{
-  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
-  int ci, tbl;
-  jpeg_component_info *compptr;
-
-  if (gather_statistics)
-    /* Make sure to avoid that in the master control logic!
-     * We are fully adaptive here and need no extra
-     * statistics gathering pass!
-     */
-    ERREXIT(cinfo, JERR_NOTIMPL);
-
-  /* We assume jcmaster.c already validated the progressive scan parameters. */
-
-  /* Select execution routines */
-  if (cinfo->progressive_mode) {
-    if (cinfo->Ah == 0) {
-      if (cinfo->Ss == 0)
-        entropy->pub.encode_mcu = encode_mcu_DC_first;
-      else
-        entropy->pub.encode_mcu = encode_mcu_AC_first;
-    } else {
-      if (cinfo->Ss == 0)
-        entropy->pub.encode_mcu = encode_mcu_DC_refine;
-      else
-        entropy->pub.encode_mcu = encode_mcu_AC_refine;
-    }
-  } else
-    entropy->pub.encode_mcu = encode_mcu;
-
-  /* Allocate & initialize requested statistics areas */
-  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
-    compptr = cinfo->cur_comp_info[ci];
-    /* DC needs no table for refinement scan */
-    if (cinfo->progressive_mode == 0 || (cinfo->Ss == 0 && cinfo->Ah == 0)) {
-      tbl = compptr->dc_tbl_no;
-      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);
-      memset(entropy->dc_stats[tbl], 0, DC_STAT_BINS);
-      /* Initialize DC predictions to 0 */
-      entropy->last_dc_val[ci] = 0;
-      entropy->dc_context[ci] = 0;
-    }
-    /* AC needs no table when not present */
-    if (cinfo->progressive_mode == 0 || cinfo->Se) {
-      tbl = compptr->ac_tbl_no;
-      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);
-      memset(entropy->ac_stats[tbl], 0, 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);
-#endif
-    }
-  }
-
-  /* Initialize arithmetic encoding variables */
-  entropy->c = 0;
-  entropy->a = 0x10000L;
-  entropy->sc = 0;
-  entropy->zc = 0;
-  entropy->ct = 11;
-  entropy->buffer = -1;  /* empty */
-
-  /* Initialize restart stuff */
-  entropy->restarts_to_go = cinfo->restart_interval;
-  entropy->next_restart_num = 0;
-}
-
-
-/*
- * Module initialization routine for arithmetic entropy encoding.
- */
-
-GLOBAL(void)
-jinit_arith_encoder(j_compress_ptr cinfo)
-{
-  arith_entropy_ptr entropy;
-  int i;
-
-  entropy = (arith_entropy_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                sizeof(arith_entropy_encoder));
-  cinfo->entropy = (struct jpeg_entropy_encoder *)entropy;
-  entropy->pub.start_pass = start_pass;
-  entropy->pub.finish_pass = finish_pass;
-
-  /* Mark tables unallocated */
-  for (i = 0; i < NUM_ARITH_TBLS; i++) {
-    entropy->dc_stats[i] = NULL;
-    entropy->ac_stats[i] = NULL;
-  }
-
-  /* Initialize index for fixed probability estimation */
-  entropy->fixed_bin[0] = 113;
-}
@@ -1,454 +0,0 @@
-/*
- * jccoefct.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1994-1997, Thomas G. Lane.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains the coefficient buffer controller for compression.
- * This controller is the top level of the lossy JPEG compressor proper.
- * The coefficient buffer lies between forward-DCT and entropy encoding steps.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jsamplecomp.h"
-
-
-/* We use a full-image coefficient buffer when doing Huffman optimization,
- * and also for writing multiple-scan JPEG files.  In all cases, the DCT
- * step is run during the first pass, and subsequent passes need only read
- * the buffered coefficients.
- */
-#ifdef ENTROPY_OPT_SUPPORTED
-#define FULL_COEF_BUFFER_SUPPORTED
-#else
-#ifdef C_MULTISCAN_FILES_SUPPORTED
-#define FULL_COEF_BUFFER_SUPPORTED
-#endif
-#endif
-
-
-/* Private buffer controller object */
-
-typedef struct {
-  struct jpeg_c_coef_controller pub; /* public fields */
-
-  JDIMENSION iMCU_row_num;      /* iMCU row # within image */
-  JDIMENSION mcu_ctr;           /* counts MCUs processed in current row */
-  int MCU_vert_offset;          /* counts MCU rows within iMCU row */
-  int MCU_rows_per_iMCU_row;    /* number of such rows needed */
-
-  /* For single-pass compression, it's sufficient to buffer just one MCU
-   * (although this may prove a bit slow in practice).  We allocate a
-   * workspace of C_MAX_BLOCKS_IN_MCU coefficient blocks, and reuse it for each
-   * MCU constructed and sent.  In multi-pass modes, this array points to the
-   * current MCU's blocks within the virtual arrays.
-   */
-  JBLOCKROW MCU_buffer[C_MAX_BLOCKS_IN_MCU];
-
-  /* In multi-pass modes, we need a virtual block array for each component. */
-  jvirt_barray_ptr whole_image[MAX_COMPONENTS];
-} my_coef_controller;
-
-typedef my_coef_controller *my_coef_ptr;
-
-
-/* Forward declarations */
-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);
-#endif
-
-
-LOCAL(void)
-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;
-
-  /* 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.
-   * But at the bottom of the image, process only what's left.
-   */
-  if (cinfo->comps_in_scan > 1) {
-    coef->MCU_rows_per_iMCU_row = 1;
-  } else {
-    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;
-  }
-
-  coef->mcu_ctr = 0;
-  coef->MCU_vert_offset = 0;
-}
-
-
-/*
- * Initialize for a processing pass.
- */
-
-METHODDEF(void)
-start_pass_coef(j_compress_ptr cinfo, J_BUF_MODE pass_mode)
-{
-  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
-
-  coef->iMCU_row_num = 0;
-  start_iMCU_row(cinfo);
-
-  switch (pass_mode) {
-  case JBUF_PASS_THRU:
-    if (coef->whole_image[0] != NULL)
-      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
-    coef->pub._compress_data = compress_data;
-    break;
-#ifdef FULL_COEF_BUFFER_SUPPORTED
-  case JBUF_SAVE_AND_PASS:
-    if (coef->whole_image[0] == NULL)
-      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
-    coef->pub._compress_data = compress_first_pass;
-    break;
-  case JBUF_CRANK_DEST:
-    if (coef->whole_image[0] == NULL)
-      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
-    coef->pub._compress_data = compress_output;
-    break;
-#endif
-  default:
-    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
-    break;
-  }
-}
-
-
-/*
- * Process some data in the single-pass case.
- * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
- * per call, ie, v_samp_factor block rows for each component in the image.
- * Returns TRUE if the iMCU row is completed, FALSE if suspended.
- *
- * NB: input_buf contains a plane for each component in image,
- * which we index according to the component's SOF position.
- */
-
-METHODDEF(boolean)
-compress_data(j_compress_ptr cinfo, _JSAMPIMAGE input_buf)
-{
-  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;
-  int blkn, bi, ci, yindex, yoffset, blockcnt;
-  JDIMENSION ypos, xpos;
-  jpeg_component_info *compptr;
-
-  /* Loop to write as much as one whole iMCU row */
-  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
-       yoffset++) {
-    for (MCU_col_num = coef->mcu_ctr; MCU_col_num <= last_MCU_col;
-         MCU_col_num++) {
-      /* Determine where data comes from in input_buf and do the DCT thing.
-       * Each call on forward_DCT processes a horizontal row of DCT blocks
-       * as wide as an MCU; we rely on having allocated the MCU_buffer[] blocks
-       * sequentially.  Dummy blocks at the right or bottom edge are filled in
-       * specially.  The data in them does not matter for image reconstruction,
-       * so we fill them with values that will encode to the smallest amount of
-       * data, viz: all zeroes in the AC entries, DC entries equal to previous
-       * block's DC value.  (Thanks to Thomas Kinsman for this idea.)
-       */
-      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;
-        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) {
-            (*cinfo->fdct->_forward_DCT) (cinfo, compptr,
-                                          input_buf[compptr->component_index],
-                                          coef->MCU_buffer[blkn],
-                                          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],
-                        (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];
-              }
-            }
-          } else {
-            /* Create a row of dummy blocks at the bottom of the image. */
-            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];
-            }
-          }
-          blkn += compptr->MCU_width;
-          ypos += DCTSIZE;
-        }
-      }
-      /* 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)) {
-        /* Suspension forced; update state counters and exit */
-        coef->MCU_vert_offset = yoffset;
-        coef->mcu_ctr = MCU_col_num;
-        return FALSE;
-      }
-    }
-    /* Completed an MCU row, but perhaps not an iMCU row */
-    coef->mcu_ctr = 0;
-  }
-  /* Completed the iMCU row, advance counters for next one */
-  coef->iMCU_row_num++;
-  start_iMCU_row(cinfo);
-  return TRUE;
-}
-
-
-#ifdef FULL_COEF_BUFFER_SUPPORTED
-
-/*
- * Process some data in the first pass of a multi-pass case.
- * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
- * per call, ie, v_samp_factor block rows for each component in the image.
- * This amount of data is read from the source buffer, DCT'd and quantized,
- * and saved into the virtual arrays.  We also generate suitable dummy blocks
- * as needed at the right and lower edges.  (The dummy blocks are constructed
- * in the virtual arrays, which have been padded appropriately.)  This makes
- * it possible for subsequent passes not to worry about real vs. dummy blocks.
- *
- * We must also emit the data to the entropy encoder.  This is conveniently
- * done by calling compress_output() after we've loaded the current strip
- * of the virtual arrays.
- *
- * NB: input_buf contains a plane for each component in image.  All
- * components are DCT'd and loaded into the virtual arrays in this pass.
- * However, it may be that only a subset of the components are emitted to
- * the entropy encoder during this first pass; be careful about looking
- * at the scan-dependent variables (MCU dimensions, etc).
- */
-
-METHODDEF(boolean)
-compress_first_pass(j_compress_ptr cinfo, _JSAMPIMAGE input_buf)
-{
-  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;
-  JCOEF lastDC;
-  jpeg_component_info *compptr;
-  JBLOCKARRAY buffer;
-  JBLOCKROW thisblockrow, lastblockrow;
-
-  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-       ci++, compptr++) {
-    /* Align the virtual buffer for this component. */
-    buffer = (*cinfo->mem->access_virt_barray)
-      ((j_common_ptr)cinfo, coef->whole_image[ci],
-       coef->iMCU_row_num * compptr->v_samp_factor,
-       (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);
-      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);
-    if (ndummy > 0)
-      ndummy = h_samp_factor - ndummy;
-    /* Perform DCT for all non-dummy blocks in this iMCU row.  Each call
-     * on forward_DCT processes a complete horizontal row of DCT blocks.
-     */
-    for (block_row = 0; block_row < block_rows; block_row++) {
-      thisblockrow = buffer[block_row];
-      (*cinfo->fdct->_forward_DCT) (cinfo, compptr,
-                                    input_buf[ci], thisblockrow,
-                                    (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));
-        lastDC = thisblockrow[-1][0];
-        for (bi = 0; bi < ndummy; bi++) {
-          thisblockrow[bi][0] = lastDC;
-        }
-      }
-    }
-    /* If at end of image, create dummy block rows as needed.
-     * The tricky part here is that within each MCU, we want the DC values
-     * of the dummy blocks to match the last real block's DC value.
-     * This squeezes a few more bytes out of the resulting file...
-     */
-    if (coef->iMCU_row_num == last_iMCU_row) {
-      blocks_across += ndummy;  /* include lower right corner */
-      MCUs_across = blocks_across / h_samp_factor;
-      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)));
-        for (MCUindex = 0; MCUindex < MCUs_across; MCUindex++) {
-          lastDC = lastblockrow[h_samp_factor - 1][0];
-          for (bi = 0; bi < h_samp_factor; bi++) {
-            thisblockrow[bi][0] = lastDC;
-          }
-          thisblockrow += h_samp_factor; /* advance to next MCU in row */
-          lastblockrow += h_samp_factor;
-        }
-      }
-    }
-  }
-  /* NB: compress_output will increment iMCU_row_num if successful.
-   * A suspension return will result in redoing all the work above next time.
-   */
-
-  /* Emit data to the entropy encoder, sharing code with subsequent passes */
-  return compress_output(cinfo, input_buf);
-}
-
-
-/*
- * Process some data in subsequent passes of a multi-pass case.
- * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
- * per call, ie, v_samp_factor block rows for each component in the scan.
- * The data is obtained from the virtual arrays and fed to the entropy coder.
- * Returns TRUE if the iMCU row is completed, FALSE if suspended.
- *
- * NB: input_buf is ignored; it is likely to be a NULL pointer.
- */
-
-METHODDEF(boolean)
-compress_output(j_compress_ptr cinfo, _JSAMPIMAGE input_buf)
-{
-  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;
-  JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
-  JBLOCKROW buffer_ptr;
-  jpeg_component_info *compptr;
-
-  /* Align the virtual buffers for the components used in this scan.
-   * NB: during first pass, this is safe only because the buffers will
-   * already be aligned properly, so jmemmgr.c won't need to do any I/O.
-   */
-  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],
-       coef->iMCU_row_num * compptr->v_samp_factor,
-       (JDIMENSION)compptr->v_samp_factor, FALSE);
-  }
-
-  /* Loop to process one whole iMCU row */
-  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
-       yoffset++) {
-    for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row;
-         MCU_col_num++) {
-      /* Construct list of pointers to DCT blocks belonging to this 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];
-        start_col = MCU_col_num * compptr->MCU_width;
-        for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
-          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)) {
-        /* Suspension forced; update state counters and exit */
-        coef->MCU_vert_offset = yoffset;
-        coef->mcu_ctr = MCU_col_num;
-        return FALSE;
-      }
-    }
-    /* Completed an MCU row, but perhaps not an iMCU row */
-    coef->mcu_ctr = 0;
-  }
-  /* Completed the iMCU row, advance counters for next one */
-  coef->iMCU_row_num++;
-  start_iMCU_row(cinfo);
-  return TRUE;
-}
-
-#endif /* FULL_COEF_BUFFER_SUPPORTED */
-
-
-/*
- * Initialize coefficient buffer controller.
- */
-
-GLOBAL(void)
-_jinit_c_coef_controller(j_compress_ptr cinfo, boolean need_full_buffer)
-{
-  my_coef_ptr coef;
-
-  if (cinfo->data_precision != BITS_IN_JSAMPLE)
-    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-
-  coef = (my_coef_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                sizeof(my_coef_controller));
-  cinfo->coef = (struct jpeg_c_coef_controller *)coef;
-  coef->pub.start_pass = start_pass_coef;
-
-  /* Create the coefficient buffer. */
-  if (need_full_buffer) {
-#ifdef FULL_COEF_BUFFER_SUPPORTED
-    /* Allocate a full-image virtual array for each component, */
-    /* padded to a multiple of samp_factor DCT blocks in each direction. */
-    int ci;
-    jpeg_component_info *compptr;
-
-    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);
-    }
-#else
-    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
-#endif
-  } else {
-    /* We only need a single-MCU buffer. */
-    JBLOCKROW buffer;
-    int i;
-
-    buffer = (JBLOCKROW)
-      (*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;
-    }
-    coef->whole_image[0] = NULL; /* flag for no virtual arrays */
-  }
-}
@@ -1,152 +0,0 @@
-/*
- * jccolext.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1991-1996, Thomas G. Lane.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2009-2012, 2015, 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains input colorspace conversion routines.
- */
-
-
-/* This file is included by jccolor.c */
-
-
-/*
- * Convert some rows of samples to the JPEG colorspace.
- *
- * Note that we change from the application's interleaved-pixel format
- * to our internal noninterleaved, one-plane-per-component format.
- * The input buffer is therefore three times as wide as the output buffer.
- *
- * A starting row offset is provided only for the output buffer.  The caller
- * can easily adjust the passed input_buf value to accommodate any row
- * offset required on that side.
- */
-
-INLINE
-LOCAL(void)
-rgb_ycc_convert_internal(j_compress_ptr cinfo, _JSAMPARRAY input_buf,
-                         _JSAMPIMAGE output_buf, JDIMENSION output_row,
-                         int num_rows)
-{
-#if BITS_IN_JSAMPLE != 16
-  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
-  register int r, g, b;
-  register JLONG *ctab = cconvert->rgb_ycc_tab;
-  register _JSAMPROW inptr;
-  register _JSAMPROW outptr0, outptr1, outptr2;
-  register JDIMENSION col;
-  JDIMENSION num_cols = cinfo->image_width;
-
-  while (--num_rows >= 0) {
-    inptr = *input_buf++;
-    outptr0 = output_buf[0][output_row];
-    outptr1 = output_buf[1][output_row];
-    outptr2 = output_buf[2][output_row];
-    output_row++;
-    for (col = 0; col < num_cols; col++) {
-      r = RANGE_LIMIT(inptr[RGB_RED]);
-      g = RANGE_LIMIT(inptr[RGB_GREEN]);
-      b = RANGE_LIMIT(inptr[RGB_BLUE]);
-      inptr += RGB_PIXELSIZE;
-      /* If the inputs are 0.._MAXJSAMPLE, the outputs of these equations
-       * must be too; we do not need an explicit range-limiting operation.
-       * Hence the value being shifted is never negative, and we don't
-       * 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);
-      /* Cb */
-      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);
-    }
-  }
-#else
-  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-#endif
-}
-
-
-/**************** Cases other than RGB -> YCbCr **************/
-
-
-/*
- * Convert some rows of samples to the JPEG colorspace.
- * This version handles RGB->grayscale conversion, which is the same
- * as the RGB->Y portion of RGB->YCbCr.
- * We assume rgb_ycc_start has been called (we only use the Y tables).
- */
-
-INLINE
-LOCAL(void)
-rgb_gray_convert_internal(j_compress_ptr cinfo, _JSAMPARRAY input_buf,
-                          _JSAMPIMAGE output_buf, JDIMENSION output_row,
-                          int num_rows)
-{
-#if BITS_IN_JSAMPLE != 16
-  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
-  register int r, g, b;
-  register JLONG *ctab = cconvert->rgb_ycc_tab;
-  register _JSAMPROW inptr;
-  register _JSAMPROW outptr;
-  register JDIMENSION col;
-  JDIMENSION num_cols = cinfo->image_width;
-
-  while (--num_rows >= 0) {
-    inptr = *input_buf++;
-    outptr = output_buf[0][output_row];
-    output_row++;
-    for (col = 0; col < num_cols; col++) {
-      r = RANGE_LIMIT(inptr[RGB_RED]);
-      g = RANGE_LIMIT(inptr[RGB_GREEN]);
-      b = RANGE_LIMIT(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);
-    }
-  }
-#else
-  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-#endif
-}
-
-
-/*
- * Convert some rows of samples to the JPEG colorspace.
- * This version handles extended RGB->plain RGB conversion
- */
-
-INLINE
-LOCAL(void)
-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;
-  register JDIMENSION col;
-  JDIMENSION num_cols = cinfo->image_width;
-
-  while (--num_rows >= 0) {
-    inptr = *input_buf++;
-    outptr0 = output_buf[0][output_row];
-    outptr1 = output_buf[1][output_row];
-    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];
-      inptr += RGB_PIXELSIZE;
-    }
-  }
-}
@@ -1,732 +0,0 @@
-/*
- * jccolor.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1991-1996, Thomas G. Lane.
- * libjpeg-turbo Modifications:
- * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
- * Copyright (C) 2009-2012, 2015, 2022, D. R. Commander.
- * Copyright (C) 2014, MIPS Technologies, Inc., California.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains input colorspace conversion routines.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jsimd.h"
-#include "jsamplecomp.h"
-
-
-#if BITS_IN_JSAMPLE != 16 || defined(C_LOSSLESS_SUPPORTED)
-
-/* Private subobject */
-
-typedef struct {
-  struct jpeg_color_converter pub; /* public fields */
-
-#if BITS_IN_JSAMPLE != 16
-  /* Private state for RGB->YCC conversion */
-  JLONG *rgb_ycc_tab;           /* => table for RGB to YCbCr conversion */
-#endif
-} my_color_converter;
-
-typedef my_color_converter *my_cconvert_ptr;
-
-
-/**************** RGB -> YCbCr conversion: most common case **************/
-
-/*
- * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
- * normalized to the range 0.._MAXJSAMPLE rather than -0.5 .. 0.5.
- * The conversion equations to be implemented are therefore
- *      Y  =  0.29900 * R + 0.58700 * G + 0.11400 * B
- *      Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B  + _CENTERJSAMPLE
- *      Cr =  0.50000 * R - 0.41869 * G - 0.08131 * B  + _CENTERJSAMPLE
- * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.)
- * Note: older versions of the IJG code used a zero offset of _MAXJSAMPLE/2,
- * rather than _CENTERJSAMPLE, for Cb and Cr.  This gave equal positive and
- * negative swings for Cb/Cr, but meant that grayscale values (Cb=Cr=0)
- * were not represented exactly.  Now we sacrifice exact representation of
- * maximum red and maximum blue in order to get exact grayscales.
- *
- * To avoid floating-point arithmetic, we represent the fractional constants
- * as integers scaled up by 2^16 (about 4 digits precision); we have to divide
- * the products by 2^16, with appropriate rounding, to get the correct answer.
- *
- * For even more speed, we avoid doing any multiplications in the inner loop
- * by precalculating the constants times R,G,B for all possible values.
- * For 8-bit samples this is very reasonable (only 256 entries per table);
- * for 12-bit samples it is still acceptable.  It's not very reasonable for
- * 16-bit samples, but if you want lossless storage you shouldn't be changing
- * colorspace anyway.
- * The _CENTERJSAMPLE offsets and the rounding fudge-factor of 0.5 are included
- * in the tables to save adding them separately in the inner loop.
- */
-
-#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))
-
-/* 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
- * address, which can be held in a register in the inner loops on many
- * machines (more than can hold all eight addresses, anyway).
- */
-
-#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 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))
-
-/* 12-bit samples use a 16-bit data type, so it is possible to pass
- * out-of-range sample values (< 0 or > 4095) to jpeg_write_scanlines().
- * Thus, we mask the incoming 12-bit samples to guard against overrunning
- * or underrunning the conversion tables.
- */
-
-#if BITS_IN_JSAMPLE == 12
-#define RANGE_LIMIT(value)  ((value) & 0xFFF)
-#else
-#define RANGE_LIMIT(value)  (value)
-#endif
-
-
-/* Include inline routines for colorspace extensions */
-
-#include "jccolext.c"
-#undef RGB_RED
-#undef RGB_GREEN
-#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
-#include "jccolext.c"
-#undef RGB_RED
-#undef RGB_GREEN
-#undef RGB_BLUE
-#undef RGB_PIXELSIZE
-#undef rgb_ycc_convert_internal
-#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
-#include "jccolext.c"
-#undef RGB_RED
-#undef RGB_GREEN
-#undef RGB_BLUE
-#undef RGB_PIXELSIZE
-#undef rgb_ycc_convert_internal
-#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
-#include "jccolext.c"
-#undef RGB_RED
-#undef RGB_GREEN
-#undef RGB_BLUE
-#undef RGB_PIXELSIZE
-#undef rgb_ycc_convert_internal
-#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
-#include "jccolext.c"
-#undef RGB_RED
-#undef RGB_GREEN
-#undef RGB_BLUE
-#undef RGB_PIXELSIZE
-#undef rgb_ycc_convert_internal
-#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
-#include "jccolext.c"
-#undef RGB_RED
-#undef RGB_GREEN
-#undef RGB_BLUE
-#undef RGB_PIXELSIZE
-#undef rgb_ycc_convert_internal
-#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
-#include "jccolext.c"
-#undef RGB_RED
-#undef RGB_GREEN
-#undef RGB_BLUE
-#undef RGB_PIXELSIZE
-#undef rgb_ycc_convert_internal
-#undef rgb_gray_convert_internal
-#undef rgb_rgb_convert_internal
-
-
-/*
- * Initialize for RGB->YCC colorspace conversion.
- */
-
-METHODDEF(void)
-rgb_ycc_start(j_compress_ptr cinfo)
-{
-#if BITS_IN_JSAMPLE != 16
-  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,
-                                (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;
-    /* 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;
-/*  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 + G_CR_OFF] = (-FIX(0.41869)) * i;
-    rgb_ycc_tab[i + B_CR_OFF] = (-FIX(0.08131)) * i;
-  }
-#else
-  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-#endif
-}
-
-
-/*
- * Convert some rows of samples to the JPEG colorspace.
- */
-
-METHODDEF(void)
-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;
-  }
-}
-
-
-/**************** Cases other than RGB -> YCbCr **************/
-
-
-/*
- * Convert some rows of samples to the JPEG colorspace.
- */
-
-METHODDEF(void)
-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;
-  }
-}
-
-
-/*
- * Extended RGB to plain RGB conversion
- */
-
-METHODDEF(void)
-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;
-  }
-}
-
-
-/*
- * Convert some rows of samples to the JPEG colorspace.
- * This version handles Adobe-style CMYK->YCCK conversion,
- * where we convert R=1-C, G=1-M, and B=1-Y to YCbCr using the same
- * conversion as above, while passing K (black) unchanged.
- * We assume rgb_ycc_start has been called.
- */
-
-METHODDEF(void)
-cmyk_ycck_convert(j_compress_ptr cinfo, _JSAMPARRAY input_buf,
-                  _JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows)
-{
-#if BITS_IN_JSAMPLE != 16
-  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
-  register int r, g, b;
-  register JLONG *ctab = cconvert->rgb_ycc_tab;
-  register _JSAMPROW inptr;
-  register _JSAMPROW outptr0, outptr1, outptr2, outptr3;
-  register JDIMENSION col;
-  JDIMENSION num_cols = cinfo->image_width;
-
-  while (--num_rows >= 0) {
-    inptr = *input_buf++;
-    outptr0 = output_buf[0][output_row];
-    outptr1 = output_buf[1][output_row];
-    outptr2 = output_buf[2][output_row];
-    outptr3 = output_buf[3][output_row];
-    output_row++;
-    for (col = 0; col < num_cols; col++) {
-      r = _MAXJSAMPLE - RANGE_LIMIT(inptr[0]);
-      g = _MAXJSAMPLE - RANGE_LIMIT(inptr[1]);
-      b = _MAXJSAMPLE - RANGE_LIMIT(inptr[2]);
-      /* K passes through as-is */
-      outptr3[col] = inptr[3];
-      inptr += 4;
-      /* If the inputs are 0.._MAXJSAMPLE, the outputs of these equations
-       * must be too; we do not need an explicit range-limiting operation.
-       * Hence the value being shifted is never negative, and we don't
-       * 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);
-      /* Cb */
-      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);
-    }
-  }
-#else
-  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-#endif
-}
-
-
-/*
- * Convert some rows of samples to the JPEG colorspace.
- * This version handles grayscale output with no conversion.
- * The source can be either plain grayscale or YCbCr (since Y == gray).
- */
-
-METHODDEF(void)
-grayscale_convert(j_compress_ptr cinfo, _JSAMPARRAY input_buf,
-                  _JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows)
-{
-  register _JSAMPROW inptr;
-  register _JSAMPROW outptr;
-  register JDIMENSION col;
-  JDIMENSION num_cols = cinfo->image_width;
-  int instride = cinfo->input_components;
-
-  while (--num_rows >= 0) {
-    inptr = *input_buf++;
-    outptr = output_buf[0][output_row];
-    output_row++;
-    for (col = 0; col < num_cols; col++) {
-      outptr[col] = inptr[0];
-      inptr += instride;
-    }
-  }
-}
-
-
-/*
- * Convert some rows of samples to the JPEG colorspace.
- * This version handles multi-component colorspaces without conversion.
- * We assume input_components == num_components.
- */
-
-METHODDEF(void)
-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;
-  register JDIMENSION col;
-  register int ci;
-  int nc = cinfo->num_components;
-  JDIMENSION num_cols = cinfo->image_width;
-
-  if (nc == 3) {
-    while (--num_rows >= 0) {
-      inptr = *input_buf++;
-      outptr0 = output_buf[0][output_row];
-      outptr1 = output_buf[1][output_row];
-      outptr2 = output_buf[2][output_row];
-      output_row++;
-      for (col = 0; col < num_cols; col++) {
-        outptr0[col] = *inptr++;
-        outptr1[col] = *inptr++;
-        outptr2[col] = *inptr++;
-      }
-    }
-  } else if (nc == 4) {
-    while (--num_rows >= 0) {
-      inptr = *input_buf++;
-      outptr0 = output_buf[0][output_row];
-      outptr1 = output_buf[1][output_row];
-      outptr2 = output_buf[2][output_row];
-      outptr3 = output_buf[3][output_row];
-      output_row++;
-      for (col = 0; col < num_cols; col++) {
-        outptr0[col] = *inptr++;
-        outptr1[col] = *inptr++;
-        outptr2[col] = *inptr++;
-        outptr3[col] = *inptr++;
-      }
-    }
-  } else {
-    while (--num_rows >= 0) {
-      /* It seems fastest to make a separate pass for each component. */
-      for (ci = 0; ci < nc; ci++) {
-        inptr = *input_buf;
-        outptr = output_buf[ci][output_row];
-        for (col = 0; col < num_cols; col++) {
-          outptr[col] = inptr[ci];
-          inptr += nc;
-        }
-      }
-      input_buf++;
-      output_row++;
-    }
-  }
-}
-
-
-/*
- * Empty method for start_pass.
- */
-
-METHODDEF(void)
-null_method(j_compress_ptr cinfo)
-{
-  /* no work needed */
-}
-
-
-/*
- * Module initialization routine for input colorspace conversion.
- */
-
-GLOBAL(void)
-_jinit_color_converter(j_compress_ptr cinfo)
-{
-  my_cconvert_ptr cconvert;
-
-  if (cinfo->data_precision != BITS_IN_JSAMPLE)
-    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-
-  cconvert = (my_cconvert_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                sizeof(my_color_converter));
-  cinfo->cconvert = (struct jpeg_color_converter *)cconvert;
-  /* set start_pass to null method until we find out differently */
-  cconvert->pub.start_pass = null_method;
-
-  /* Make sure input_components agrees with in_color_space */
-  switch (cinfo->in_color_space) {
-  case JCS_GRAYSCALE:
-    if (cinfo->input_components != 1)
-      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
-    break;
-
-  case JCS_RGB:
-  case JCS_EXT_RGB:
-  case JCS_EXT_RGBX:
-  case JCS_EXT_BGR:
-  case JCS_EXT_BGRX:
-  case JCS_EXT_XBGR:
-  case JCS_EXT_XRGB:
-  case JCS_EXT_RGBA:
-  case JCS_EXT_BGRA:
-  case JCS_EXT_ABGR:
-  case JCS_EXT_ARGB:
-    if (cinfo->input_components != rgb_pixelsize[cinfo->in_color_space])
-      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
-    break;
-
-  case JCS_YCbCr:
-    if (cinfo->input_components != 3)
-      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
-    break;
-
-  case JCS_CMYK:
-  case JCS_YCCK:
-    if (cinfo->input_components != 4)
-      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
-    break;
-
-  default:                      /* JCS_UNKNOWN can be anything */
-    if (cinfo->input_components < 1)
-      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
-    break;
-  }
-
-  /* Check num_components, set conversion method based on requested space.
-   * NOTE: We do not allow any lossy color conversion algorithms in lossless
-   * mode.
-   */
-  switch (cinfo->jpeg_color_space) {
-  case JCS_GRAYSCALE:
-    if (cinfo->master->lossless &&
-        cinfo->in_color_space != cinfo->jpeg_color_space)
-      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    if (cinfo->num_components != 1)
-      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
-    if (cinfo->in_color_space == JCS_GRAYSCALE)
-      cconvert->pub._color_convert = grayscale_convert;
-    else if (IsExtRGB(cinfo->in_color_space)) {
-#ifdef WITH_SIMD
-      if (jsimd_can_rgb_gray())
-        cconvert->pub._color_convert = jsimd_rgb_gray_convert;
-      else
-#endif
-      {
-        cconvert->pub.start_pass = rgb_ycc_start;
-        cconvert->pub._color_convert = rgb_gray_convert;
-      }
-    } else if (cinfo->in_color_space == JCS_YCbCr)
-      cconvert->pub._color_convert = grayscale_convert;
-    else
-      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    break;
-
-  case JCS_RGB:
-    if (cinfo->master->lossless && !IsExtRGB(cinfo->in_color_space))
-      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    if (cinfo->num_components != 3)
-      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
-    if (rgb_red[cinfo->in_color_space] == 0 &&
-        rgb_green[cinfo->in_color_space] == 1 &&
-        rgb_blue[cinfo->in_color_space] == 2 &&
-        rgb_pixelsize[cinfo->in_color_space] == 3) {
-#if defined(WITH_SIMD) && defined(__mips__)
-      if (jsimd_c_can_null_convert())
-        cconvert->pub._color_convert = jsimd_c_null_convert;
-      else
-#endif
-        cconvert->pub._color_convert = null_convert;
-    } else if (IsExtRGB(cinfo->in_color_space))
-      cconvert->pub._color_convert = rgb_rgb_convert;
-    else
-      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    break;
-
-  case JCS_YCbCr:
-    if (cinfo->master->lossless &&
-        cinfo->in_color_space != cinfo->jpeg_color_space)
-      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    if (cinfo->num_components != 3)
-      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
-    if (IsExtRGB(cinfo->in_color_space)) {
-#ifdef WITH_SIMD
-      if (jsimd_can_rgb_ycc())
-        cconvert->pub._color_convert = jsimd_rgb_ycc_convert;
-      else
-#endif
-      {
-        cconvert->pub.start_pass = rgb_ycc_start;
-        cconvert->pub._color_convert = rgb_ycc_convert;
-      }
-    } else if (cinfo->in_color_space == JCS_YCbCr) {
-#if defined(WITH_SIMD) && defined(__mips__)
-      if (jsimd_c_can_null_convert())
-        cconvert->pub._color_convert = jsimd_c_null_convert;
-      else
-#endif
-        cconvert->pub._color_convert = null_convert;
-    } else
-      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    break;
-
-  case JCS_CMYK:
-    if (cinfo->master->lossless &&
-        cinfo->in_color_space != cinfo->jpeg_color_space)
-      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    if (cinfo->num_components != 4)
-      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
-    if (cinfo->in_color_space == JCS_CMYK) {
-#if defined(WITH_SIMD) && defined(__mips__)
-      if (jsimd_c_can_null_convert())
-        cconvert->pub._color_convert = jsimd_c_null_convert;
-      else
-#endif
-        cconvert->pub._color_convert = null_convert;
-    } else
-      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    break;
-
-  case JCS_YCCK:
-    if (cinfo->master->lossless &&
-        cinfo->in_color_space != cinfo->jpeg_color_space)
-      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    if (cinfo->num_components != 4)
-      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
-    if (cinfo->in_color_space == JCS_CMYK) {
-      cconvert->pub.start_pass = rgb_ycc_start;
-      cconvert->pub._color_convert = cmyk_ycck_convert;
-    } else if (cinfo->in_color_space == JCS_YCCK) {
-#if defined(WITH_SIMD) && defined(__mips__)
-      if (jsimd_c_can_null_convert())
-        cconvert->pub._color_convert = jsimd_c_null_convert;
-      else
-#endif
-        cconvert->pub._color_convert = null_convert;
-    } else
-      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    break;
-
-  default:                      /* allow null conversion of JCS_UNKNOWN */
-    if (cinfo->jpeg_color_space != cinfo->in_color_space ||
-        cinfo->num_components != cinfo->input_components)
-      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-#if defined(WITH_SIMD) && defined(__mips__)
-    if (jsimd_c_can_null_convert())
-      cconvert->pub._color_convert = jsimd_c_null_convert;
-    else
-#endif
-      cconvert->pub._color_convert = null_convert;
-    break;
-  }
-}
-
-#endif /* BITS_IN_JSAMPLE != 16 || defined(C_LOSSLESS_SUPPORTED) */
@@ -1,748 +0,0 @@
-/*
- * jcdctmgr.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1994-1996, Thomas G. Lane.
- * libjpeg-turbo Modifications:
- * Copyright (C) 1999-2006, MIYASAKA Masaru.
- * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
- * Copyright (C) 2011, 2014-2015, 2022, 2024, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains the forward-DCT management logic.
- * This code selects a particular DCT implementation to be used,
- * and it performs related housekeeping chores including coefficient
- * quantization.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jdct.h"               /* Private declarations for DCT subsystem */
-#include "jsimddct.h"
-
-
-/* Private subobject for this module */
-
-typedef void (*forward_DCT_method_ptr) (DCTELEM *data);
-typedef void (*float_DCT_method_ptr) (FAST_FLOAT *data);
-
-typedef void (*convsamp_method_ptr) (_JSAMPARRAY sample_data,
-                                     JDIMENSION start_col,
-                                     DCTELEM *workspace);
-typedef void (*float_convsamp_method_ptr) (_JSAMPARRAY sample_data,
-                                           JDIMENSION start_col,
-                                           FAST_FLOAT *workspace);
-
-typedef void (*quantize_method_ptr) (JCOEFPTR coef_block, DCTELEM *divisors,
-                                     DCTELEM *workspace);
-typedef void (*float_quantize_method_ptr) (JCOEFPTR coef_block,
-                                           FAST_FLOAT *divisors,
-                                           FAST_FLOAT *workspace);
-
-METHODDEF(void) quantize(JCOEFPTR, DCTELEM *, DCTELEM *);
-
-typedef struct {
-  struct jpeg_forward_dct pub;  /* public fields */
-
-  /* Pointer to the DCT routine actually in use */
-  forward_DCT_method_ptr dct;
-  convsamp_method_ptr convsamp;
-  quantize_method_ptr quantize;
-
-  /* The actual post-DCT divisors --- not identical to the quant table
-   * entries, because of scaling (especially for an unnormalized DCT).
-   * Each table is given in normal array order.
-   */
-  DCTELEM *divisors[NUM_QUANT_TBLS];
-
-  /* work area for FDCT subroutine */
-  DCTELEM *workspace;
-
-#ifdef DCT_FLOAT_SUPPORTED
-  /* Same as above for the floating-point case. */
-  float_DCT_method_ptr float_dct;
-  float_convsamp_method_ptr float_convsamp;
-  float_quantize_method_ptr float_quantize;
-  FAST_FLOAT *float_divisors[NUM_QUANT_TBLS];
-  FAST_FLOAT *float_workspace;
-#endif
-} my_fdct_controller;
-
-typedef my_fdct_controller *my_fdct_ptr;
-
-
-#if BITS_IN_JSAMPLE == 8
-
-/*
- * Find the highest bit in an integer through binary search.
- */
-
-LOCAL(int)
-flss(UINT16 val)
-{
-  int bit;
-
-  bit = 16;
-
-  if (!val)
-    return 0;
-
-  if (!(val & 0xff00)) {
-    bit -= 8;
-    val <<= 8;
-  }
-  if (!(val & 0xf000)) {
-    bit -= 4;
-    val <<= 4;
-  }
-  if (!(val & 0xc000)) {
-    bit -= 2;
-    val <<= 2;
-  }
-  if (!(val & 0x8000)) {
-    bit -= 1;
-    val <<= 1;
-  }
-
-  return bit;
-}
-
-
-/*
- * Compute values to do a division using reciprocal.
- *
- * This implementation is based on an algorithm described in
- *   "Optimizing subroutines in assembly language:
- *   An optimization guide for x86 platforms" (https://agner.org/optimize).
- * More information about the basic algorithm can be found in
- * the paper "Integer Division Using Reciprocals" by Robert Alverson.
- *
- * The basic idea is to replace x/d by x * d^-1. In order to store
- * d^-1 with enough precision we shift it left a few places. It turns
- * out that this algoright gives just enough precision, and also fits
- * into DCTELEM:
- *
- *   b = (the number of significant bits in divisor) - 1
- *   r = (word size) + b
- *   f = 2^r / divisor
- *
- * f will not be an integer for most cases, so we need to compensate
- * for the rounding error introduced:
- *
- *   no fractional part:
- *
- *       result = input >> r
- *
- *   fractional part of f < 0.5:
- *
- *       round f down to nearest integer
- *       result = ((input + 1) * f) >> r
- *
- *   fractional part of f > 0.5:
- *
- *       round f up to nearest integer
- *       result = (input * f) >> r
- *
- * This is the original algorithm that gives truncated results. But we
- * want properly rounded results, so we replace "input" with
- * "input + divisor/2".
- *
- * In order to allow SIMD implementations we also tweak the values to
- * allow the same calculation to be made at all times:
- *
- *   dctbl[0] = f rounded to nearest integer
- *   dctbl[1] = divisor / 2 (+ 1 if fractional part of f < 0.5)
- *   dctbl[2] = 1 << ((word size) * 2 - r)
- *   dctbl[3] = r - (word size)
- *
- * dctbl[2] is for stupid instruction sets where the shift operation
- * isn't member wise (e.g. MMX).
- *
- * The reason dctbl[2] and dctbl[3] reduce the shift with (word size)
- * is that most SIMD implementations have a "multiply and store top
- * half" operation.
- *
- * Lastly, we store each of the values in their own table instead
- * of in a consecutive manner, yet again in order to allow SIMD
- * routines.
- */
-
-LOCAL(int)
-compute_reciprocal(UINT16 divisor, DCTELEM *dtbl)
-{
-  UDCTELEM2 fq, fr;
-  UDCTELEM c;
-  int b, r;
-
-  if (divisor == 1) {
-    /* divisor == 1 means unquantized, so these reciprocal/correction/shift
-     * values will cause the C quantization algorithm to act like the
-     * 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 */
-    return 0;
-  }
-
-  b = flss(divisor) - 1;
-  r  = sizeof(DCTELEM) * 8 + b;
-
-  fq = ((UDCTELEM2)1 << r) / divisor;
-  fr = ((UDCTELEM2)1 << r) % divisor;
-
-  c = divisor / 2;                      /* for rounding */
-
-  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 */
-    c++;
-  } else {                              /* fractional part is > 0.5 */
-    fq++;
-  }
-
-  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 */
-#else
-  dtbl[DCTSIZE2 * 2] = 1;
-#endif
-  dtbl[DCTSIZE2 * 3] = (DCTELEM)r - sizeof(DCTELEM) * 8; /* shift */
-
-  if (r <= 16) return 0;
-  else return 1;
-}
-
-#endif
-
-
-/*
- * Initialize for a processing pass.
- * Verify that all referenced Q-tables are present, and set up
- * the divisor table for each one.
- * In the current implementation, DCT of all components is done during
- * the first pass, even if only some components will be output in the
- * first scan.  Hence all components should be examined here.
- */
-
-METHODDEF(void)
-start_pass_fdctmgr(j_compress_ptr cinfo)
-{
-  my_fdct_ptr fdct = (my_fdct_ptr)cinfo->fdct;
-  int ci, qtblno, i;
-  jpeg_component_info *compptr;
-  JQUANT_TBL *qtbl;
-  DCTELEM *dtbl;
-
-  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-       ci++, compptr++) {
-    qtblno = compptr->quant_tbl_no;
-    /* Make sure specified quantization table is present */
-    if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS ||
-        cinfo->quant_tbl_ptrs[qtblno] == NULL)
-      ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno);
-    qtbl = cinfo->quant_tbl_ptrs[qtblno];
-    /* Compute divisors for this quant table */
-    /* We may do this more than once for same table, but it's not a big deal */
-    switch (cinfo->dct_method) {
-#ifdef DCT_ISLOW_SUPPORTED
-    case JDCT_ISLOW:
-      /* For LL&M IDCT method, divisors are equal to raw quantization
-       * coefficients multiplied by 8 (to counteract scaling).
-       */
-      if (fdct->divisors[qtblno] == NULL) {
-        fdct->divisors[qtblno] = (DCTELEM *)
-          (*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
-#ifdef WITH_SIMD
-        if (!compute_reciprocal(qtbl->quantval[i] << 3, &dtbl[i]) &&
-            fdct->quantize == jsimd_quantize)
-          fdct->quantize = quantize;
-#else
-        compute_reciprocal(qtbl->quantval[i] << 3, &dtbl[i]);
-#endif
-#else
-        dtbl[i] = ((DCTELEM)qtbl->quantval[i]) << 3;
-#endif
-      }
-      break;
-#endif
-#ifdef DCT_IFAST_SUPPORTED
-    case JDCT_IFAST:
-      {
-        /* For AA&N IDCT method, divisors are equal to quantization
-         * coefficients scaled by scalefactor[row]*scalefactor[col], where
-         *   scalefactor[0] = 1
-         *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
-         * We apply a further scale factor of 8.
-         */
-#define CONST_BITS  14
-        static const INT16 aanscales[DCTSIZE2] = {
-          /* precomputed values scaled up by 14 bits */
-          16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
-          22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
-          21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
-          19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
-          16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
-          12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
-           8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
-           4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
-        };
-        SHIFT_TEMPS
-
-        if (fdct->divisors[qtblno] == NULL) {
-          fdct->divisors[qtblno] = (DCTELEM *)
-            (*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
-#ifdef WITH_SIMD
-          if (!compute_reciprocal(
-                DESCALE(MULTIPLY16V16((JLONG)qtbl->quantval[i],
-                                      (JLONG)aanscales[i]),
-                        CONST_BITS - 3), &dtbl[i]) &&
-              fdct->quantize == jsimd_quantize)
-            fdct->quantize = quantize;
-#else
-          compute_reciprocal(
-            DESCALE(MULTIPLY16V16((JLONG)qtbl->quantval[i],
-                                  (JLONG)aanscales[i]),
-                    CONST_BITS-3), &dtbl[i]);
-#endif
-#else
-          dtbl[i] = (DCTELEM)
-            DESCALE(MULTIPLY16V16((JLONG)qtbl->quantval[i],
-                                  (JLONG)aanscales[i]),
-                    CONST_BITS - 3);
-#endif
-        }
-      }
-      break;
-#endif
-#ifdef DCT_FLOAT_SUPPORTED
-    case JDCT_FLOAT:
-      {
-        /* For float AA&N IDCT method, divisors are equal to quantization
-         * coefficients scaled by scalefactor[row]*scalefactor[col], where
-         *   scalefactor[0] = 1
-         *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
-         * We apply a further scale factor of 8.
-         * What's actually stored is 1/divisor so that the inner loop can
-         * use a multiplication rather than a division.
-         */
-        FAST_FLOAT *fdtbl;
-        int row, col;
-        static const double aanscalefactor[DCTSIZE] = {
-          1.0, 1.387039845, 1.306562965, 1.175875602,
-          1.0, 0.785694958, 0.541196100, 0.275899379
-        };
-
-        if (fdct->float_divisors[qtblno] == NULL) {
-          fdct->float_divisors[qtblno] = (FAST_FLOAT *)
-            (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                        DCTSIZE2 * sizeof(FAST_FLOAT));
-        }
-        fdtbl = fdct->float_divisors[qtblno];
-        i = 0;
-        for (row = 0; row < DCTSIZE; row++) {
-          for (col = 0; col < DCTSIZE; col++) {
-            fdtbl[i] = (FAST_FLOAT)
-              (1.0 / (((double)qtbl->quantval[i] *
-                       aanscalefactor[row] * aanscalefactor[col] * 8.0)));
-            i++;
-          }
-        }
-      }
-      break;
-#endif
-    default:
-      ERREXIT(cinfo, JERR_NOT_COMPILED);
-      break;
-    }
-  }
-}
-
-
-/*
- * Load data into workspace, applying unsigned->signed conversion.
- */
-
-METHODDEF(void)
-convsamp(_JSAMPARRAY sample_data, JDIMENSION start_col, DCTELEM *workspace)
-{
-  register DCTELEM *workspaceptr;
-  register _JSAMPROW elemptr;
-  register int elemr;
-
-  workspaceptr = workspace;
-  for (elemr = 0; elemr < DCTSIZE; elemr++) {
-    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;
-#else
-    {
-      register int elemc;
-      for (elemc = DCTSIZE; elemc > 0; elemc--)
-        *workspaceptr++ = (*elemptr++) - _CENTERJSAMPLE;
-    }
-#endif
-  }
-}
-
-
-/*
- * Quantize/descale the coefficients, and store into coef_blocks[].
- */
-
-METHODDEF(void)
-quantize(JCOEFPTR coef_block, DCTELEM *divisors, DCTELEM *workspace)
-{
-  int i;
-  DCTELEM temp;
-  JCOEFPTR output_ptr = coef_block;
-
-#if BITS_IN_JSAMPLE == 8
-
-  UDCTELEM recip, corr;
-  int shift;
-  UDCTELEM2 product;
-
-  for (i = 0; i < DCTSIZE2; i++) {
-    temp = workspace[i];
-    recip = divisors[i + DCTSIZE2 * 0];
-    corr =  divisors[i + DCTSIZE2 * 1];
-    shift = divisors[i + DCTSIZE2 * 3];
-
-    if (temp < 0) {
-      temp = -temp;
-      product = (UDCTELEM2)(temp + corr) * recip;
-      product >>= shift + sizeof(DCTELEM) * 8;
-      temp = (DCTELEM)product;
-      temp = -temp;
-    } else {
-      product = (UDCTELEM2)(temp + corr) * recip;
-      product >>= shift + sizeof(DCTELEM) * 8;
-      temp = (DCTELEM)product;
-    }
-    output_ptr[i] = (JCOEF)temp;
-  }
-
-#else
-
-  register DCTELEM qval;
-
-  for (i = 0; i < DCTSIZE2; i++) {
-    qval = divisors[i];
-    temp = workspace[i];
-    /* Divide the coefficient value by qval, ensuring proper rounding.
-     * Since C does not specify the direction of rounding for negative
-     * quotients, we have to force the dividend positive for portability.
-     *
-     * In most files, at least half of the output values will be zero
-     * (at default quantization settings, more like three-quarters...)
-     * so we should ensure that this case is fast.  On many machines,
-     * a comparison is enough cheaper than a divide to make a special test
-     * a win.  Since both inputs will be nonnegative, we need only test
-     * for a < b to discover whether a/b is 0.
-     * If your machine's division is fast enough, define FAST_DIVIDE.
-     */
-#ifdef FAST_DIVIDE
-#define DIVIDE_BY(a, b)  a /= b
-#else
-#define DIVIDE_BY(a, b)  if (a >= b) a /= b;  else a = 0
-#endif
-    if (temp < 0) {
-      temp = -temp;
-      temp += qval >> 1;        /* for rounding */
-      DIVIDE_BY(temp, qval);
-      temp = -temp;
-    } else {
-      temp += qval >> 1;        /* for rounding */
-      DIVIDE_BY(temp, qval);
-    }
-    output_ptr[i] = (JCOEF)temp;
-  }
-
-#endif
-
-}
-
-
-/*
- * Perform forward DCT on one or more blocks of a component.
- *
- * The input samples are taken from the sample_data[] array starting at
- * position start_row/start_col, and moving to the right for any additional
- * blocks. The quantized coefficients are returned in coef_blocks[].
- */
-
-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)
-/* 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;
-  DCTELEM *divisors = fdct->divisors[compptr->quant_tbl_no];
-  DCTELEM *workspace;
-  JDIMENSION bi;
-
-  /* Make sure the compiler doesn't look up these every pass */
-  forward_DCT_method_ptr do_dct = fdct->dct;
-  convsamp_method_ptr do_convsamp = fdct->convsamp;
-  quantize_method_ptr do_quantize = fdct->quantize;
-  workspace = fdct->workspace;
-
-  sample_data += start_row;     /* fold in the vertical offset once */
-
-  for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) {
-    /* Load data into workspace, applying unsigned->signed conversion */
-    (*do_convsamp) (sample_data, start_col, workspace);
-
-    /* Perform the DCT */
-    (*do_dct) (workspace);
-
-    /* Quantize/descale the coefficients, and store into coef_blocks[] */
-    (*do_quantize) (coef_blocks[bi], divisors, workspace);
-  }
-}
-
-
-#ifdef DCT_FLOAT_SUPPORTED
-
-METHODDEF(void)
-convsamp_float(_JSAMPARRAY sample_data, JDIMENSION start_col,
-               FAST_FLOAT *workspace)
-{
-  register FAST_FLOAT *workspaceptr;
-  register _JSAMPROW elemptr;
-  register int elemr;
-
-  workspaceptr = workspace;
-  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);
-#else
-    {
-      register int elemc;
-      for (elemc = DCTSIZE; elemc > 0; elemc--)
-        *workspaceptr++ = (FAST_FLOAT)((*elemptr++) - _CENTERJSAMPLE);
-    }
-#endif
-  }
-}
-
-
-METHODDEF(void)
-quantize_float(JCOEFPTR coef_block, FAST_FLOAT *divisors,
-               FAST_FLOAT *workspace)
-{
-  register FAST_FLOAT temp;
-  register int i;
-  register JCOEFPTR output_ptr = coef_block;
-
-  for (i = 0; i < DCTSIZE2; i++) {
-    /* Apply the quantization and scaling factor */
-    temp = workspace[i] * divisors[i];
-
-    /* Round to nearest integer.
-     * Since C does not specify the direction of rounding for negative
-     * quotients, we have to force the dividend positive for portability.
-     * 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);
-  }
-}
-
-
-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)
-/* 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;
-  FAST_FLOAT *divisors = fdct->float_divisors[compptr->quant_tbl_no];
-  FAST_FLOAT *workspace;
-  JDIMENSION bi;
-
-
-  /* Make sure the compiler doesn't look up these every pass */
-  float_DCT_method_ptr do_dct = fdct->float_dct;
-  float_convsamp_method_ptr do_convsamp = fdct->float_convsamp;
-  float_quantize_method_ptr do_quantize = fdct->float_quantize;
-  workspace = fdct->float_workspace;
-
-  sample_data += start_row;     /* fold in the vertical offset once */
-
-  for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) {
-    /* Load data into workspace, applying unsigned->signed conversion */
-    (*do_convsamp) (sample_data, start_col, workspace);
-
-    /* Perform the DCT */
-    (*do_dct) (workspace);
-
-    /* Quantize/descale the coefficients, and store into coef_blocks[] */
-    (*do_quantize) (coef_blocks[bi], divisors, workspace);
-  }
-}
-
-#endif /* DCT_FLOAT_SUPPORTED */
-
-
-/*
- * Initialize FDCT manager.
- */
-
-GLOBAL(void)
-_jinit_forward_dct(j_compress_ptr cinfo)
-{
-  my_fdct_ptr fdct;
-  int i;
-
-  if (cinfo->data_precision != BITS_IN_JSAMPLE)
-    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-
-  fdct = (my_fdct_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                sizeof(my_fdct_controller));
-  cinfo->fdct = (struct jpeg_forward_dct *)fdct;
-  fdct->pub.start_pass = start_pass_fdctmgr;
-
-  /* First determine the DCT... */
-  switch (cinfo->dct_method) {
-#ifdef DCT_ISLOW_SUPPORTED
-  case JDCT_ISLOW:
-    fdct->pub._forward_DCT = forward_DCT;
-#ifdef WITH_SIMD
-    if (jsimd_can_fdct_islow())
-      fdct->dct = jsimd_fdct_islow;
-    else
-#endif
-      fdct->dct = _jpeg_fdct_islow;
-    break;
-#endif
-#ifdef DCT_IFAST_SUPPORTED
-  case JDCT_IFAST:
-    fdct->pub._forward_DCT = forward_DCT;
-#ifdef WITH_SIMD
-    if (jsimd_can_fdct_ifast())
-      fdct->dct = jsimd_fdct_ifast;
-    else
-#endif
-      fdct->dct = _jpeg_fdct_ifast;
-    break;
-#endif
-#ifdef DCT_FLOAT_SUPPORTED
-  case JDCT_FLOAT:
-    fdct->pub._forward_DCT = forward_DCT_float;
-#ifdef WITH_SIMD
-    if (jsimd_can_fdct_float())
-      fdct->float_dct = jsimd_fdct_float;
-    else
-#endif
-      fdct->float_dct = jpeg_fdct_float;
-    break;
-#endif
-  default:
-    ERREXIT(cinfo, JERR_NOT_COMPILED);
-    break;
-  }
-
-  /* ...then the supporting stages. */
-  switch (cinfo->dct_method) {
-#ifdef DCT_ISLOW_SUPPORTED
-  case JDCT_ISLOW:
-#endif
-#ifdef DCT_IFAST_SUPPORTED
-  case JDCT_IFAST:
-#endif
-#if defined(DCT_ISLOW_SUPPORTED) || defined(DCT_IFAST_SUPPORTED)
-#ifdef WITH_SIMD
-    if (jsimd_can_convsamp())
-      fdct->convsamp = jsimd_convsamp;
-    else
-#endif
-      fdct->convsamp = convsamp;
-#ifdef WITH_SIMD
-    if (jsimd_can_quantize())
-      fdct->quantize = jsimd_quantize;
-    else
-#endif
-      fdct->quantize = quantize;
-    break;
-#endif
-#ifdef DCT_FLOAT_SUPPORTED
-  case JDCT_FLOAT:
-#ifdef WITH_SIMD
-    if (jsimd_can_convsamp_float())
-      fdct->float_convsamp = jsimd_convsamp_float;
-    else
-#endif
-      fdct->float_convsamp = convsamp_float;
-#ifdef WITH_SIMD
-    if (jsimd_can_quantize_float())
-      fdct->float_quantize = jsimd_quantize_float;
-    else
-#endif
-      fdct->float_quantize = quantize_float;
-    break;
-#endif
-  default:
-    ERREXIT(cinfo, JERR_NOT_COMPILED);
-    break;
-  }
-
-  /* Allocate workspace memory */
-#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,
-                                  sizeof(FAST_FLOAT) * DCTSIZE2);
-  else
-#endif
-    fdct->workspace = (DCTELEM *)
-      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                  sizeof(DCTELEM) * DCTSIZE2);
-
-  /* Mark divisor tables unallocated */
-  for (i = 0; i < NUM_QUANT_TBLS; i++) {
-    fdct->divisors[i] = NULL;
-#ifdef DCT_FLOAT_SUPPORTED
-    fdct->float_divisors[i] = NULL;
-#endif
-  }
-}
@@ -1,411 +0,0 @@
-/*
- * jcdiffct.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1994-1997, Thomas G. Lane.
- * Lossless JPEG Modifications:
- * Copyright (C) 1999, Ken Murchison.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains the difference buffer controller for compression.
- * This controller is the top level of the lossless JPEG compressor proper.
- * The difference buffer lies between the prediction/differencing and entropy
- * encoding steps.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jlossls.h"            /* Private declarations for lossless codec */
-
-
-#ifdef C_LOSSLESS_SUPPORTED
-
-/* We use a full-image sample buffer when doing Huffman optimization,
- * and also for writing multiple-scan JPEG files.  In all cases, the
- * full-image buffer is filled during the first pass, and the scaling,
- * prediction and differencing steps are run during subsequent passes.
- */
-#ifdef ENTROPY_OPT_SUPPORTED
-#define FULL_SAMP_BUFFER_SUPPORTED
-#else
-#ifdef C_MULTISCAN_FILES_SUPPORTED
-#define FULL_SAMP_BUFFER_SUPPORTED
-#endif
-#endif
-
-
-/* Private buffer controller object */
-
-typedef struct {
-  struct jpeg_c_coef_controller pub; /* public fields */
-
-  JDIMENSION iMCU_row_num;      /* iMCU row # within image */
-  JDIMENSION mcu_ctr;           /* counts MCUs processed in current row */
-  int MCU_vert_offset;          /* counts MCU rows within iMCU row */
-  int MCU_rows_per_iMCU_row;    /* number of such rows needed */
-
-  _JSAMPROW cur_row[MAX_COMPONENTS];    /* row of point-transformed samples */
-  _JSAMPROW prev_row[MAX_COMPONENTS];   /* previous row of Pt'd samples */
-  JDIFFARRAY diff_buf[MAX_COMPONENTS];  /* iMCU row of differences */
-
-  /* In multi-pass modes, we need a virtual sample array for each component. */
-  jvirt_sarray_ptr whole_image[MAX_COMPONENTS];
-} my_diff_controller;
-
-typedef my_diff_controller *my_diff_ptr;
-
-
-/* Forward declarations */
-METHODDEF(boolean) compress_data(j_compress_ptr cinfo, _JSAMPIMAGE input_buf);
-#ifdef FULL_SAMP_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);
-#endif
-
-
-LOCAL(void)
-start_iMCU_row(j_compress_ptr cinfo)
-/* Reset within-iMCU-row counters for a new row */
-{
-  my_diff_ptr diff = (my_diff_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.
-   * But at the bottom of the image, process only what's left.
-   */
-  if (cinfo->comps_in_scan > 1) {
-    diff->MCU_rows_per_iMCU_row = 1;
-  } else {
-    if (diff->iMCU_row_num < (cinfo->total_iMCU_rows-1))
-      diff->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
-    else
-      diff->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
-  }
-
-  diff->mcu_ctr = 0;
-  diff->MCU_vert_offset = 0;
-}
-
-
-/*
- * Initialize for a processing pass.
- */
-
-METHODDEF(void)
-start_pass_diff(j_compress_ptr cinfo, J_BUF_MODE pass_mode)
-{
-  my_diff_ptr diff = (my_diff_ptr)cinfo->coef;
-
-  /* Because it is hitching a ride on the jpeg_forward_dct struct,
-   * start_pass_lossless() will be called at the start of the initial pass.
-   * This ensures that it will be called at the start of the Huffman
-   * optimization and output passes as well.
-   */
-  if (pass_mode == JBUF_CRANK_DEST)
-    (*cinfo->fdct->start_pass) (cinfo);
-
-  diff->iMCU_row_num = 0;
-  start_iMCU_row(cinfo);
-
-  switch (pass_mode) {
-  case JBUF_PASS_THRU:
-    if (diff->whole_image[0] != NULL)
-      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
-    diff->pub._compress_data = compress_data;
-    break;
-#ifdef FULL_SAMP_BUFFER_SUPPORTED
-  case JBUF_SAVE_AND_PASS:
-    if (diff->whole_image[0] == NULL)
-      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
-    diff->pub._compress_data = compress_first_pass;
-    break;
-  case JBUF_CRANK_DEST:
-    if (diff->whole_image[0] == NULL)
-      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
-    diff->pub._compress_data = compress_output;
-    break;
-#endif
-  default:
-    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
-    break;
-  }
-}
-
-
-#define SWAP_ROWS(rowa, rowb) { \
-  _JSAMPROW temp = rowa; \
-  rowa = rowb;  rowb = temp; \
-}
-
-/*
- * Process some data in the single-pass case.
- * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
- * per call, ie, v_samp_factor rows for each component in the image.
- * Returns TRUE if the iMCU row is completed, FALSE if suspended.
- *
- * NB: input_buf contains a plane for each component in image,
- * which we index according to the component's SOF position.
- */
-
-METHODDEF(boolean)
-compress_data(j_compress_ptr cinfo, _JSAMPIMAGE input_buf)
-{
-  my_diff_ptr diff = (my_diff_ptr)cinfo->coef;
-  lossless_comp_ptr losslessc = (lossless_comp_ptr)cinfo->fdct;
-  JDIMENSION MCU_col_num;       /* index of current MCU within row */
-  JDIMENSION MCU_count;         /* number of MCUs encoded */
-  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
-  int ci, compi, yoffset, samp_row, samp_rows, samps_across;
-  jpeg_component_info *compptr;
-
-  /* Loop to write as much as one whole iMCU row */
-  for (yoffset = diff->MCU_vert_offset; yoffset < diff->MCU_rows_per_iMCU_row;
-       yoffset++) {
-
-    MCU_col_num = diff->mcu_ctr;
-
-    /* Scale and predict each scanline of the MCU row separately.
-     *
-     * Note: We only do this if we are at the start of an MCU row, ie,
-     * we don't want to reprocess a row suspended by the output.
-     */
-    if (MCU_col_num == 0) {
-      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
-        compptr = cinfo->cur_comp_info[ci];
-        compi = compptr->component_index;
-        if (diff->iMCU_row_num < last_iMCU_row)
-          samp_rows = compptr->v_samp_factor;
-        else {
-          /* NB: can't use last_row_height here, since may not be set! */
-          samp_rows =
-            (int)(compptr->height_in_blocks % compptr->v_samp_factor);
-          if (samp_rows == 0) samp_rows = compptr->v_samp_factor;
-          else {
-            /* Fill dummy difference rows at the bottom edge with zeros, which
-             * will encode to the smallest amount of data.
-             */
-            for (samp_row = samp_rows; samp_row < compptr->v_samp_factor;
-                 samp_row++)
-              memset(diff->diff_buf[compi][samp_row], 0,
-                     jround_up((long)compptr->width_in_blocks,
-                               (long)compptr->h_samp_factor) * sizeof(JDIFF));
-          }
-        }
-        samps_across = compptr->width_in_blocks;
-
-        for (samp_row = 0; samp_row < samp_rows; samp_row++) {
-          (*losslessc->scaler_scale) (cinfo,
-                                      input_buf[compi][samp_row],
-                                      diff->cur_row[compi],
-                                      samps_across);
-          (*losslessc->predict_difference[compi])
-            (cinfo, compi, diff->cur_row[compi], diff->prev_row[compi],
-             diff->diff_buf[compi][samp_row], samps_across);
-          SWAP_ROWS(diff->cur_row[compi], diff->prev_row[compi]);
-        }
-      }
-    }
-    /* Try to write the MCU row (or remaining portion of suspended MCU row). */
-    MCU_count =
-      (*cinfo->entropy->encode_mcus) (cinfo,
-                                      diff->diff_buf, yoffset, MCU_col_num,
-                                      cinfo->MCUs_per_row - MCU_col_num);
-    if (MCU_count != cinfo->MCUs_per_row - MCU_col_num) {
-      /* Suspension forced; update state counters and exit */
-      diff->MCU_vert_offset = yoffset;
-      diff->mcu_ctr += MCU_col_num;
-      return FALSE;
-    }
-    /* Completed an MCU row, but perhaps not an iMCU row */
-    diff->mcu_ctr = 0;
-  }
-  /* Completed the iMCU row, advance counters for next one */
-  diff->iMCU_row_num++;
-  start_iMCU_row(cinfo);
-  return TRUE;
-}
-
-
-#ifdef FULL_SAMP_BUFFER_SUPPORTED
-
-/*
- * Process some data in the first pass of a multi-pass case.
- * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
- * per call, ie, v_samp_factor rows for each component in the image.
- * This amount of data is read from the source buffer and saved into the
- * virtual arrays.
- *
- * We must also emit the data to the compressor.  This is conveniently
- * done by calling compress_output() after we've loaded the current strip
- * of the virtual arrays.
- *
- * NB: input_buf contains a plane for each component in image.  All components
- * are loaded into the virtual arrays in this pass.  However, it may be that
- * only a subset of the components are emitted to the compressor during
- * this first pass; be careful about looking at the scan-dependent variables
- * (MCU dimensions, etc).
- */
-
-METHODDEF(boolean)
-compress_first_pass(j_compress_ptr cinfo, _JSAMPIMAGE input_buf)
-{
-  my_diff_ptr diff = (my_diff_ptr)cinfo->coef;
-  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
-  JDIMENSION samps_across;
-  int ci, samp_row, samp_rows;
-  _JSAMPARRAY buffer;
-  jpeg_component_info *compptr;
-
-  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-       ci++, compptr++) {
-    /* Align the virtual buffer for this component. */
-    buffer = (_JSAMPARRAY)(*cinfo->mem->access_virt_sarray)
-      ((j_common_ptr)cinfo, diff->whole_image[ci],
-       diff->iMCU_row_num * compptr->v_samp_factor,
-       (JDIMENSION)compptr->v_samp_factor, TRUE);
-
-    /* Count non-dummy sample rows in this iMCU row. */
-    if (diff->iMCU_row_num < last_iMCU_row)
-      samp_rows = compptr->v_samp_factor;
-    else {
-      /* NB: can't use last_row_height here, since may not be set! */
-      samp_rows = (int)(compptr->height_in_blocks % compptr->v_samp_factor);
-      if (samp_rows == 0) samp_rows = compptr->v_samp_factor;
-    }
-    samps_across = compptr->width_in_blocks;
-
-    /* Perform point transform scaling and prediction/differencing for all
-     * non-dummy rows in this iMCU row.  Each call on these functions
-     * processes a complete row of samples.
-     */
-    for (samp_row = 0; samp_row < samp_rows; samp_row++) {
-      memcpy(buffer[samp_row], input_buf[ci][samp_row],
-             samps_across * sizeof(_JSAMPLE));
-    }
-  }
-  /* NB: compress_output will increment iMCU_row_num if successful.
-   * A suspension return will result in redoing all the work above next time.
-   */
-
-  /* Emit data to the compressor, sharing code with subsequent passes */
-  return compress_output(cinfo, input_buf);
-}
-
-
-/*
- * Process some data in subsequent passes of a multi-pass case.
- * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
- * per call, ie, v_samp_factor rows for each component in the scan.
- * The data is obtained from the virtual arrays and fed to the compressor.
- * Returns TRUE if the iMCU row is completed, FALSE if suspended.
- *
- * NB: input_buf is ignored; it is likely to be a NULL pointer.
- */
-
-METHODDEF(boolean)
-compress_output(j_compress_ptr cinfo, _JSAMPIMAGE input_buf)
-{
-  my_diff_ptr diff = (my_diff_ptr)cinfo->coef;
-  int ci, compi;
-  _JSAMPARRAY buffer[MAX_COMPS_IN_SCAN];
-  jpeg_component_info *compptr;
-
-  /* Align the virtual buffers for the components used in this scan.
-   * NB: during first pass, this is safe only because the buffers will
-   * already be aligned properly, so jmemmgr.c won't need to do any I/O.
-   */
-  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
-    compptr = cinfo->cur_comp_info[ci];
-    compi = compptr->component_index;
-    buffer[compi] = (_JSAMPARRAY)(*cinfo->mem->access_virt_sarray)
-      ((j_common_ptr)cinfo, diff->whole_image[compi],
-       diff->iMCU_row_num * compptr->v_samp_factor,
-       (JDIMENSION)compptr->v_samp_factor, FALSE);
-  }
-
-  return compress_data(cinfo, buffer);
-}
-
-#endif /* FULL_SAMP_BUFFER_SUPPORTED */
-
-
-/*
- * Initialize difference buffer controller.
- */
-
-GLOBAL(void)
-_jinit_c_diff_controller(j_compress_ptr cinfo, boolean need_full_buffer)
-{
-  my_diff_ptr diff;
-  int ci, row;
-  jpeg_component_info *compptr;
-
-  diff = (my_diff_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                sizeof(my_diff_controller));
-  cinfo->coef = (struct jpeg_c_coef_controller *)diff;
-  diff->pub.start_pass = start_pass_diff;
-
-  /* Create the prediction row buffers. */
-  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-       ci++, compptr++) {
-    diff->cur_row[ci] = *(_JSAMPARRAY)(*cinfo->mem->alloc_sarray)
-      ((j_common_ptr)cinfo, JPOOL_IMAGE,
-       (JDIMENSION)jround_up((long)compptr->width_in_blocks,
-                             (long)compptr->h_samp_factor),
-       (JDIMENSION)1);
-    diff->prev_row[ci] = *(_JSAMPARRAY)(*cinfo->mem->alloc_sarray)
-      ((j_common_ptr)cinfo, JPOOL_IMAGE,
-       (JDIMENSION)jround_up((long)compptr->width_in_blocks,
-                             (long)compptr->h_samp_factor),
-       (JDIMENSION)1);
-  }
-
-  /* Create the difference buffer. */
-  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-       ci++, compptr++) {
-    diff->diff_buf[ci] =
-      ALLOC_DARRAY(JPOOL_IMAGE,
-                   (JDIMENSION)jround_up((long)compptr->width_in_blocks,
-                                         (long)compptr->h_samp_factor),
-                   (JDIMENSION)compptr->v_samp_factor);
-    /* Prefill difference rows with zeros.  We do this because only actual
-     * data is placed in the buffers during prediction/differencing, leaving
-     * any dummy differences at the right edge as zeros, which will encode
-     * to the smallest amount of data.
-     */
-    for (row = 0; row < compptr->v_samp_factor; row++)
-      memset(diff->diff_buf[ci][row], 0,
-             jround_up((long)compptr->width_in_blocks,
-                       (long)compptr->h_samp_factor) * sizeof(JDIFF));
-  }
-
-  /* Create the sample buffer. */
-  if (need_full_buffer) {
-#ifdef FULL_SAMP_BUFFER_SUPPORTED
-    /* Allocate a full-image virtual array for each component, */
-    /* padded to a multiple of samp_factor differences in each direction. */
-    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-         ci++, compptr++) {
-      diff->whole_image[ci] = (*cinfo->mem->request_virt_sarray)
-        ((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);
-#endif
-  } else
-    diff->whole_image[0] = NULL; /* flag for no virtual arrays */
-}
-
-#endif /* C_LOSSLESS_SUPPORTED */
@@ -1,44 +0,0 @@
-/*
- * jchuff.h
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1991-1997, Thomas G. Lane.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains declarations for Huffman entropy encoding routines
- * that are shared between the sequential encoder (jchuff.c) and the
- * progressive encoder (jcphuff.c).  No other modules need to see these.
- */
-
-/* The legal range of a DCT coefficient is
- *  -1024 .. +1023  for 8-bit data;
- * -16384 .. +16383 for 12-bit data.
- * Hence the magnitude should always fit in 10 or 14 bits respectively.
- */
-
-/* The progressive Huffman encoder uses an unsigned 16-bit data type to store
- * absolute values of coefficients, because it is possible to inject a
- * coefficient value of -32768 into the encoder by attempting to transform a
- * malformed 12-bit JPEG image, and the absolute value of -32768 would overflow
- * a signed 16-bit integer.
- */
-typedef unsigned short UJCOEF;
-
-/* Derived data constructed for each Huffman table */
-
-typedef struct {
-  unsigned int ehufco[256];     /* code for each symbol */
-  char ehufsi[256];             /* length of code for each symbol */
-  /* If no code has been allocated for a symbol S, ehufsi[S] contains 0 */
-} 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);
-
-/* Generate an optimal table definition given the specified counts */
-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,149 +0,0 @@
-/*
- * jcinit.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1991-1997, Thomas G. Lane.
- * Lossless JPEG Modifications:
- * Copyright (C) 1999, Ken Murchison.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2020, 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains initialization logic for the JPEG compressor.
- * This routine is in charge of selecting the modules to be executed and
- * making an initialization call to each one.
- *
- * Logically, this code belongs in jcmaster.c.  It's split out because
- * linking this routine implies linking the entire compression library.
- * For a transcoding-only application, we want to be able to use jcmaster.c
- * without linking in the whole library.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jpegapicomp.h"
-
-
-/*
- * Master selection of compression modules.
- * This is done once at the start of processing an image.  We determine
- * which modules will be used and give them appropriate initialization calls.
- */
-
-GLOBAL(void)
-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->data_precision == 16) {
-#ifdef C_LOSSLESS_SUPPORTED
-      j16init_color_converter(cinfo);
-      j16init_downsampler(cinfo);
-      j16init_c_prep_controller(cinfo,
-                                FALSE /* never need full buffer here */);
-#else
-      ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-#endif
-    } else if (cinfo->data_precision == 12) {
-      j12init_color_converter(cinfo);
-      j12init_downsampler(cinfo);
-      j12init_c_prep_controller(cinfo,
-                                FALSE /* never need full buffer here */);
-    } else {
-      jinit_color_converter(cinfo);
-      jinit_downsampler(cinfo);
-      jinit_c_prep_controller(cinfo, FALSE /* never need full buffer here */);
-    }
-  }
-
-  if (cinfo->master->lossless) {
-#ifdef C_LOSSLESS_SUPPORTED
-    /* Prediction, sample differencing, and point transform */
-    if (cinfo->data_precision == 16)
-      j16init_lossless_compressor(cinfo);
-    else if (cinfo->data_precision == 12)
-      j12init_lossless_compressor(cinfo);
-    else
-      jinit_lossless_compressor(cinfo);
-    /* Entropy encoding: either Huffman or arithmetic coding. */
-    if (cinfo->arith_code) {
-      ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
-    } else {
-      jinit_lhuff_encoder(cinfo);
-    }
-
-    /* Need a full-image difference buffer in any multi-pass mode. */
-    if (cinfo->data_precision == 16)
-      j16init_c_diff_controller(cinfo, (boolean)(cinfo->num_scans > 1 ||
-                                                 cinfo->optimize_coding));
-    else if (cinfo->data_precision == 12)
-      j12init_c_diff_controller(cinfo, (boolean)(cinfo->num_scans > 1 ||
-                                                 cinfo->optimize_coding));
-    else
-      jinit_c_diff_controller(cinfo, (boolean)(cinfo->num_scans > 1 ||
-                                               cinfo->optimize_coding));
-#else
-    ERREXIT(cinfo, JERR_NOT_COMPILED);
-#endif
-  } else {
-    if (cinfo->data_precision == 16)
-      ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-    /* Forward DCT */
-    if (cinfo->data_precision == 12)
-      j12init_forward_dct(cinfo);
-    else
-      jinit_forward_dct(cinfo);
-    /* Entropy encoding: either Huffman or arithmetic coding. */
-    if (cinfo->arith_code) {
-#ifdef C_ARITH_CODING_SUPPORTED
-      jinit_arith_encoder(cinfo);
-#else
-      ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
-#endif
-    } else {
-      if (cinfo->progressive_mode) {
-#ifdef C_PROGRESSIVE_SUPPORTED
-        jinit_phuff_encoder(cinfo);
-#else
-        ERREXIT(cinfo, JERR_NOT_COMPILED);
-#endif
-      } else
-        jinit_huff_encoder(cinfo);
-    }
-
-    /* Need a full-image coefficient buffer in any multi-pass mode. */
-    if (cinfo->data_precision == 12)
-      j12init_c_coef_controller(cinfo, (boolean)(cinfo->num_scans > 1 ||
-                                                 cinfo->optimize_coding));
-    else
-      jinit_c_coef_controller(cinfo, (boolean)(cinfo->num_scans > 1 ||
-                                               cinfo->optimize_coding));
-  }
-
-  if (cinfo->data_precision == 16)
-#ifdef C_LOSSLESS_SUPPORTED
-    j16init_c_main_controller(cinfo, FALSE /* never need full buffer here */);
-#else
-    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-#endif
-  else if (cinfo->data_precision == 12)
-    j12init_c_main_controller(cinfo, FALSE /* never need full buffer here */);
-  else
-    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);
-
-  /* Write the datastream header (SOI) immediately.
-   * Frame and scan headers are postponed till later.
-   * This lets application insert special markers after the SOI.
-   */
-  (*cinfo->marker->write_file_header) (cinfo);
-}
@@ -1,587 +0,0 @@
-/*
- * jclhuff.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1991-1997, Thomas G. Lane.
- * Lossless JPEG Modifications:
- * Copyright (C) 1999, Ken Murchison.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains Huffman entropy encoding routines for lossless JPEG.
- *
- * Much of the complexity here has to do with supporting output suspension.
- * If the data destination module demands suspension, we want to be able to
- * back 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 JPEG objects only upon successful completion of an MCU.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jlossls.h"            /* Private declarations for lossless codec */
-#include "jchuff.h"             /* Declarations shared with jc*huff.c */
-
-
-#ifdef C_LOSSLESS_SUPPORTED
-
-/* The legal range of a spatial difference is
- * -32767 .. +32768.
- * Hence the magnitude should always fit in 16 bits.
- */
-
-#define MAX_DIFF_BITS  16
-
-
-/* Expanded entropy encoder object for Huffman encoding in lossless mode.
- *
- * The savable_state subrecord contains fields that change within an MCU,
- * but must not be updated permanently until we complete the MCU.
- */
-
-typedef struct {
-  size_t put_buffer;            /* current bit-accumulation buffer */
-  int put_bits;                 /* # of bits now in it */
-} savable_state;
-
-
-typedef struct {
-  int ci, yoffset, MCU_width;
-} lhe_input_ptr_info;
-
-
-typedef struct {
-  struct jpeg_entropy_encoder pub; /* public fields */
-
-  savable_state saved;          /* Bit buffer at start of MCU */
-
-  /* These fields are NOT loaded into local working state. */
-  unsigned int restarts_to_go;  /* MCUs left in this restart interval */
-  int next_restart_num;         /* next restart number to write (0-7) */
-
-  /* Pointers to derived tables (these workspaces have image lifespan) */
-  c_derived_tbl *derived_tbls[NUM_HUFF_TBLS];
-
-  /* Pointers to derived tables to be used for each data unit within an MCU */
-  c_derived_tbl *cur_tbls[C_MAX_BLOCKS_IN_MCU];
-
-#ifdef ENTROPY_OPT_SUPPORTED    /* Statistics tables for optimization */
-  long *count_ptrs[NUM_HUFF_TBLS];
-
-  /* Pointers to stats tables to be used for each data unit within an MCU */
-  long *cur_counts[C_MAX_BLOCKS_IN_MCU];
-#endif
-
-  /* Pointers to the proper input difference row for each group of data units
-   * within an MCU.  For each component, there are Vi groups of Hi data units.
-   */
-  JDIFFROW input_ptr[C_MAX_BLOCKS_IN_MCU];
-
-  /* Number of input pointers in use for the current MCU.  This is the sum
-   * of all Vi in the MCU.
-   */
-  int num_input_ptrs;
-
-  /* Information used for positioning the input pointers within the input
-   * difference rows.
-   */
-  lhe_input_ptr_info input_ptr_info[C_MAX_BLOCKS_IN_MCU];
-
-  /* Index of the proper input pointer for each data unit within an MCU */
-  int input_ptr_index[C_MAX_BLOCKS_IN_MCU];
-
-} lhuff_entropy_encoder;
-
-typedef lhuff_entropy_encoder *lhuff_entropy_ptr;
-
-/* Working state while writing an MCU.
- * This struct contains all the fields that are needed by subroutines.
- */
-
-typedef struct {
-  JOCTET *next_output_byte;     /* => next byte to write in buffer */
-  size_t free_in_buffer;        /* # of byte spaces remaining in buffer */
-  savable_state cur;            /* Current bit buffer & DC state */
-  j_compress_ptr cinfo;         /* dump_buffer needs access to this */
-} working_state;
-
-
-/* Forward declarations */
-METHODDEF(JDIMENSION) encode_mcus_huff(j_compress_ptr cinfo,
-                                       JDIFFIMAGE diff_buf,
-                                       JDIMENSION MCU_row_num,
-                                       JDIMENSION MCU_col_num,
-                                       JDIMENSION nMCU);
-METHODDEF(void) finish_pass_huff(j_compress_ptr cinfo);
-#ifdef ENTROPY_OPT_SUPPORTED
-METHODDEF(JDIMENSION) encode_mcus_gather(j_compress_ptr cinfo,
-                                         JDIFFIMAGE diff_buf,
-                                         JDIMENSION MCU_row_num,
-                                         JDIMENSION MCU_col_num,
-                                         JDIMENSION nMCU);
-METHODDEF(void) finish_pass_gather(j_compress_ptr cinfo);
-#endif
-
-
-/*
- * Initialize for a Huffman-compressed scan.
- * If gather_statistics is TRUE, we do not output anything during the scan,
- * just count the Huffman symbols used and generate Huffman code tables.
- */
-
-METHODDEF(void)
-start_pass_lhuff(j_compress_ptr cinfo, boolean gather_statistics)
-{
-  lhuff_entropy_ptr entropy = (lhuff_entropy_ptr)cinfo->entropy;
-  int ci, dctbl, sampn, ptrn, yoffset, xoffset;
-  jpeg_component_info *compptr;
-
-  if (gather_statistics) {
-#ifdef ENTROPY_OPT_SUPPORTED
-    entropy->pub.encode_mcus = encode_mcus_gather;
-    entropy->pub.finish_pass = finish_pass_gather;
-#else
-    ERREXIT(cinfo, JERR_NOT_COMPILED);
-#endif
-  } else {
-    entropy->pub.encode_mcus = encode_mcus_huff;
-    entropy->pub.finish_pass = finish_pass_huff;
-  }
-
-  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
-    compptr = cinfo->cur_comp_info[ci];
-    dctbl = compptr->dc_tbl_no;
-    if (gather_statistics) {
-#ifdef ENTROPY_OPT_SUPPORTED
-      /* Check for invalid table indexes */
-      /* (make_c_derived_tbl does this in the other path) */
-      if (dctbl < 0 || dctbl >= NUM_HUFF_TBLS)
-        ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, dctbl);
-      /* Allocate and zero the statistics tables */
-      /* Note that jpeg_gen_optimal_table expects 257 entries in each table! */
-      if (entropy->count_ptrs[dctbl] == NULL)
-        entropy->count_ptrs[dctbl] = (long *)
-          (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                      257 * sizeof(long));
-      memset(entropy->count_ptrs[dctbl], 0, 257 * sizeof(long));
-#endif
-    } else {
-      /* Compute derived values for Huffman tables */
-      /* We may do this more than once for a table, but it's not expensive */
-      jpeg_make_c_derived_tbl(cinfo, TRUE, dctbl,
-                              &entropy->derived_tbls[dctbl]);
-    }
-  }
-
-  /* Precalculate encoding info for each sample in an MCU of this scan */
-  for (sampn = 0, ptrn = 0; sampn < cinfo->blocks_in_MCU;) {
-    compptr = cinfo->cur_comp_info[cinfo->MCU_membership[sampn]];
-    ci = compptr->component_index;
-    for (yoffset = 0; yoffset < compptr->MCU_height; yoffset++, ptrn++) {
-      /* Precalculate the setup info for each input pointer */
-      entropy->input_ptr_info[ptrn].ci = ci;
-      entropy->input_ptr_info[ptrn].yoffset = yoffset;
-      entropy->input_ptr_info[ptrn].MCU_width = compptr->MCU_width;
-      for (xoffset = 0; xoffset < compptr->MCU_width; xoffset++, sampn++) {
-        /* Precalculate the input pointer index for each sample */
-        entropy->input_ptr_index[sampn] = ptrn;
-        /* Precalculate which tables to use for each sample */
-        entropy->cur_tbls[sampn] = entropy->derived_tbls[compptr->dc_tbl_no];
-        entropy->cur_counts[sampn] = entropy->count_ptrs[compptr->dc_tbl_no];
-      }
-    }
-  }
-  entropy->num_input_ptrs = ptrn;
-
-  /* Initialize bit buffer to empty */
-  entropy->saved.put_buffer = 0;
-  entropy->saved.put_bits = 0;
-
-  /* Initialize restart stuff */
-  entropy->restarts_to_go = cinfo->restart_interval;
-  entropy->next_restart_num = 0;
-}
-
-
-/* Outputting bytes to the file */
-
-/* Emit a byte, taking 'action' if must suspend. */
-#define emit_byte(state, val, action) { \
-  *(state)->next_output_byte++ = (JOCTET)(val); \
-  if (--(state)->free_in_buffer == 0) \
-    if (!dump_buffer(state)) \
-      { action; } \
-}
-
-
-LOCAL(boolean)
-dump_buffer(working_state *state)
-/* Empty the output buffer; return TRUE if successful, FALSE if must suspend */
-{
-  struct jpeg_destination_mgr *dest = state->cinfo->dest;
-
-  if (!(*dest->empty_output_buffer) (state->cinfo))
-    return FALSE;
-  /* After a successful buffer dump, must reset buffer pointers */
-  state->next_output_byte = dest->next_output_byte;
-  state->free_in_buffer = dest->free_in_buffer;
-  return TRUE;
-}
-
-
-/* Outputting bits to the file */
-
-/* Only the right 24 bits of put_buffer are used; the valid bits are
- * left-justified in this part.  At most 16 bits can be passed to emit_bits
- * in one call, and we never retain more than 7 bits in put_buffer
- * between calls, so 24 bits are sufficient.
- */
-
-INLINE
-LOCAL(boolean)
-emit_bits(working_state *state, unsigned int code, int size)
-/* Emit some bits; return TRUE if successful, FALSE if must suspend */
-{
-  /* This routine is heavily used, so it's worth coding tightly. */
-  register size_t put_buffer = (size_t)code;
-  register int put_bits = state->cur.put_bits;
-
-  /* if size is 0, caller used an invalid Huffman table entry */
-  if (size == 0)
-    ERREXIT(state->cinfo, JERR_HUFF_MISSING_CODE);
-
-  put_buffer &= (((size_t)1) << size) - 1; /* mask off any extra bits in code */
-
-  put_bits += size;             /* new number of bits in buffer */
-
-  put_buffer <<= 24 - put_bits; /* align incoming bits */
-
-  put_buffer |= state->cur.put_buffer; /* and merge with old buffer contents */
-
-  while (put_bits >= 8) {
-    int c = (int)((put_buffer >> 16) & 0xFF);
-
-    emit_byte(state, c, return FALSE);
-    if (c == 0xFF) {            /* need to stuff a zero byte? */
-      emit_byte(state, 0, return FALSE);
-    }
-    put_buffer <<= 8;
-    put_bits -= 8;
-  }
-
-  state->cur.put_buffer = put_buffer; /* update state variables */
-  state->cur.put_bits = put_bits;
-
-  return TRUE;
-}
-
-
-LOCAL(boolean)
-flush_bits(working_state *state)
-{
-  if (!emit_bits(state, 0x7F, 7)) /* fill any partial byte with ones */
-    return FALSE;
-  state->cur.put_buffer = 0;    /* and reset bit-buffer to empty */
-  state->cur.put_bits = 0;
-  return TRUE;
-}
-
-
-/*
- * Emit a restart marker & resynchronize predictions.
- */
-
-LOCAL(boolean)
-emit_restart(working_state *state, int restart_num)
-{
-  if (!flush_bits(state))
-    return FALSE;
-
-  emit_byte(state, 0xFF, return FALSE);
-  emit_byte(state, JPEG_RST0 + restart_num, return FALSE);
-
-  /* The restart counter is not updated until we successfully write the MCU. */
-
-  return TRUE;
-}
-
-
-/*
- * Encode and output nMCU MCUs' worth of Huffman-compressed differences.
- */
-
-METHODDEF(JDIMENSION)
-encode_mcus_huff(j_compress_ptr cinfo, JDIFFIMAGE diff_buf,
-                 JDIMENSION MCU_row_num, JDIMENSION MCU_col_num,
-                 JDIMENSION nMCU)
-{
-  lhuff_entropy_ptr entropy = (lhuff_entropy_ptr)cinfo->entropy;
-  working_state state;
-  int sampn, ci, yoffset, MCU_width, ptrn;
-  JDIMENSION mcu_num;
-
-  /* Load up working state */
-  state.next_output_byte = cinfo->dest->next_output_byte;
-  state.free_in_buffer = cinfo->dest->free_in_buffer;
-  state.cur = entropy->saved;
-  state.cinfo = cinfo;
-
-  /* Emit restart marker if needed */
-  if (cinfo->restart_interval) {
-    if (entropy->restarts_to_go == 0)
-      if (!emit_restart(&state, entropy->next_restart_num))
-        return 0;
-  }
-
-  /* Set input pointer locations based on MCU_col_num */
-  for (ptrn = 0; ptrn < entropy->num_input_ptrs; ptrn++) {
-    ci = entropy->input_ptr_info[ptrn].ci;
-    yoffset = entropy->input_ptr_info[ptrn].yoffset;
-    MCU_width = entropy->input_ptr_info[ptrn].MCU_width;
-    entropy->input_ptr[ptrn] =
-      diff_buf[ci][MCU_row_num + yoffset] + (MCU_col_num * MCU_width);
-  }
-
-  for (mcu_num = 0; mcu_num < nMCU; mcu_num++) {
-
-    /* Inner loop handles the samples in the MCU */
-    for (sampn = 0; sampn < cinfo->blocks_in_MCU; sampn++) {
-      register int temp, temp2;
-      register int nbits;
-      c_derived_tbl *dctbl = entropy->cur_tbls[sampn];
-
-      /* Encode the difference per section H.1.2.2 */
-
-      /* Input the sample difference */
-      temp = *entropy->input_ptr[entropy->input_ptr_index[sampn]]++;
-
-      if (temp & 0x8000) {      /* instead of temp < 0 */
-        temp = (-temp) & 0x7FFF; /* absolute value, mod 2^16 */
-        if (temp == 0)          /* special case: magnitude = 32768 */
-          temp2 = temp = 0x8000;
-        temp2 = ~temp;          /* one's complement of magnitude */
-      } else {
-        temp &= 0x7FFF;         /* abs value mod 2^16 */
-        temp2 = temp;           /* magnitude */
-      }
-
-      /* Find the number of bits needed for the magnitude of the difference */
-      nbits = 0;
-      while (temp) {
-        nbits++;
-        temp >>= 1;
-      }
-      /* Check for out-of-range difference values.
-       */
-      if (nbits > MAX_DIFF_BITS)
-        ERREXIT(cinfo, JERR_BAD_DCT_COEF);
-
-      /* Emit the Huffman-coded symbol for the number of bits */
-      if (!emit_bits(&state, dctbl->ehufco[nbits], dctbl->ehufsi[nbits]))
-        return mcu_num;
-
-      /* 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 */
-          nbits != 16)          /* special case: no bits should be emitted */
-        if (!emit_bits(&state, (unsigned int)temp2, nbits))
-          return mcu_num;
-    }
-
-    /* Completed MCU, so update state */
-    cinfo->dest->next_output_byte = state.next_output_byte;
-    cinfo->dest->free_in_buffer = state.free_in_buffer;
-    entropy->saved = state.cur;
-
-    /* Update restart-interval state too */
-    if (cinfo->restart_interval) {
-      if (entropy->restarts_to_go == 0) {
-        entropy->restarts_to_go = cinfo->restart_interval;
-        entropy->next_restart_num++;
-        entropy->next_restart_num &= 7;
-      }
-      entropy->restarts_to_go--;
-    }
-
-  }
-
-  return nMCU;
-}
-
-
-/*
- * Finish up at the end of a Huffman-compressed scan.
- */
-
-METHODDEF(void)
-finish_pass_huff(j_compress_ptr cinfo)
-{
-  lhuff_entropy_ptr entropy = (lhuff_entropy_ptr)cinfo->entropy;
-  working_state state;
-
-  /* Load up working state ... flush_bits needs it */
-  state.next_output_byte = cinfo->dest->next_output_byte;
-  state.free_in_buffer = cinfo->dest->free_in_buffer;
-  state.cur = entropy->saved;
-  state.cinfo = cinfo;
-
-  /* Flush out the last data */
-  if (!flush_bits(&state))
-    ERREXIT(cinfo, JERR_CANT_SUSPEND);
-
-  /* Update state */
-  cinfo->dest->next_output_byte = state.next_output_byte;
-  cinfo->dest->free_in_buffer = state.free_in_buffer;
-  entropy->saved = state.cur;
-}
-
-
-/*
- * Huffman coding optimization.
- *
- * We first scan the supplied data and count the number of uses of each symbol
- * that is to be Huffman-coded. (This process MUST agree with the code above.)
- * Then we build a Huffman coding tree for the observed counts.
- * Symbols which are not needed at all for the particular image are not
- * assigned any code, which saves space in the DHT marker as well as in
- * the compressed data.
- */
-
-#ifdef ENTROPY_OPT_SUPPORTED
-
-/*
- * Trial-encode nMCU MCUs' worth of Huffman-compressed differences.
- * No data is actually output, so no suspension return is possible.
- */
-
-METHODDEF(JDIMENSION)
-encode_mcus_gather(j_compress_ptr cinfo, JDIFFIMAGE diff_buf,
-                   JDIMENSION MCU_row_num, JDIMENSION MCU_col_num,
-                   JDIMENSION nMCU)
-{
-  lhuff_entropy_ptr entropy = (lhuff_entropy_ptr)cinfo->entropy;
-  int sampn, ci, yoffset, MCU_width, ptrn;
-  JDIMENSION mcu_num;
-
-  /* Take care of restart intervals if needed */
-  if (cinfo->restart_interval) {
-    if (entropy->restarts_to_go == 0) {
-      /* Update restart state */
-      entropy->restarts_to_go = cinfo->restart_interval;
-    }
-    entropy->restarts_to_go--;
-  }
-
-  /* Set input pointer locations based on MCU_col_num */
-  for (ptrn = 0; ptrn < entropy->num_input_ptrs; ptrn++) {
-    ci = entropy->input_ptr_info[ptrn].ci;
-    yoffset = entropy->input_ptr_info[ptrn].yoffset;
-    MCU_width = entropy->input_ptr_info[ptrn].MCU_width;
-    entropy->input_ptr[ptrn] =
-      diff_buf[ci][MCU_row_num + yoffset] + (MCU_col_num * MCU_width);
-  }
-
-  for (mcu_num = 0; mcu_num < nMCU; mcu_num++) {
-
-    /* Inner loop handles the samples in the MCU */
-    for (sampn = 0; sampn < cinfo->blocks_in_MCU; sampn++) {
-      register int temp;
-      register int nbits;
-      long *counts = entropy->cur_counts[sampn];
-
-      /* Encode the difference per section H.1.2.2 */
-
-      /* Input the sample difference */
-      temp = *entropy->input_ptr[entropy->input_ptr_index[sampn]]++;
-
-      if (temp & 0x8000) {      /* instead of temp < 0 */
-        temp = (-temp) & 0x7FFF; /* absolute value, mod 2^16 */
-        if (temp == 0)          /* special case: magnitude = 32768 */
-          temp = 0x8000;
-      } else
-        temp &= 0x7FFF;         /* abs value mod 2^16 */
-
-      /* Find the number of bits needed for the magnitude of the difference */
-      nbits = 0;
-      while (temp) {
-        nbits++;
-        temp >>= 1;
-      }
-      /* Check for out-of-range difference values.
-       */
-      if (nbits > MAX_DIFF_BITS)
-        ERREXIT(cinfo, JERR_BAD_DCT_COEF);
-
-      /* Count the Huffman symbol for the number of bits */
-      counts[nbits]++;
-    }
-  }
-
-  return nMCU;
-}
-
-
-/*
- * Finish up a statistics-gathering pass and create the new Huffman tables.
- */
-
-METHODDEF(void)
-finish_pass_gather(j_compress_ptr cinfo)
-{
-  lhuff_entropy_ptr entropy = (lhuff_entropy_ptr)cinfo->entropy;
-  int ci, dctbl;
-  jpeg_component_info *compptr;
-  JHUFF_TBL **htblptr;
-  boolean did_dc[NUM_HUFF_TBLS];
-
-  /* It's important not to apply jpeg_gen_optimal_table more than once
-   * per table, because it clobbers the input frequency counts!
-   */
-  memset(did_dc, 0, sizeof(did_dc));
-
-  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
-    compptr = cinfo->cur_comp_info[ci];
-    dctbl = compptr->dc_tbl_no;
-    if (!did_dc[dctbl]) {
-      htblptr = &cinfo->dc_huff_tbl_ptrs[dctbl];
-      if (*htblptr == NULL)
-        *htblptr = jpeg_alloc_huff_table((j_common_ptr)cinfo);
-      jpeg_gen_optimal_table(cinfo, *htblptr, entropy->count_ptrs[dctbl]);
-      did_dc[dctbl] = TRUE;
-    }
-  }
-}
-
-
-#endif /* ENTROPY_OPT_SUPPORTED */
-
-
-/*
- * Module initialization routine for Huffman entropy encoding.
- */
-
-GLOBAL(void)
-jinit_lhuff_encoder(j_compress_ptr cinfo)
-{
-  lhuff_entropy_ptr entropy;
-  int i;
-
-  entropy = (lhuff_entropy_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                sizeof(lhuff_entropy_encoder));
-  cinfo->entropy = (struct jpeg_entropy_encoder *)entropy;
-  entropy->pub.start_pass = start_pass_lhuff;
-
-  /* Mark tables unallocated */
-  for (i = 0; i < NUM_HUFF_TBLS; i++) {
-    entropy->derived_tbls[i] = NULL;
-#ifdef ENTROPY_OPT_SUPPORTED
-    entropy->count_ptrs[i] = NULL;
-#endif
-  }
-}
-
-#endif /* C_LOSSLESS_SUPPORTED */
@@ -1,319 +0,0 @@
-/*
- * jclossls.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1998, Thomas G. Lane.
- * Lossless JPEG Modifications:
- * Copyright (C) 1999, Ken Murchison.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains prediction, sample differencing, and point transform
- * routines for the lossless JPEG compressor.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jlossls.h"
-
-#ifdef C_LOSSLESS_SUPPORTED
-
-
-/************************** Sample differencing **************************/
-
-/*
- * In order to avoid a performance penalty for checking which predictor is
- * being used and which row is being processed for each call of the
- * undifferencer, and to promote optimization, we have separate differencing
- * functions for each predictor selection value.
- *
- * We are able to avoid duplicating source code by implementing the predictors
- * and differencers as macros.  Each of the differencing functions is simply a
- * wrapper around a DIFFERENCE macro with the appropriate PREDICTOR macro
- * passed as an argument.
- */
-
-/* Forward declarations */
-LOCAL(void) reset_predictor(j_compress_ptr cinfo, int ci);
-
-
-/* Predictor for the first column of the first row: 2^(P-Pt-1) */
-#define INITIAL_PREDICTORx  (1 << (cinfo->data_precision - cinfo->Al - 1))
-
-/* Predictor for the first column of the remaining rows: Rb */
-#define INITIAL_PREDICTOR2  prev_row[0]
-
-
-/*
- * 1-Dimensional differencer routine.
- *
- * This macro implements the 1-D horizontal predictor (1).  INITIAL_PREDICTOR
- * is used as the special case predictor for the first column, which must be
- * either INITIAL_PREDICTOR2 or INITIAL_PREDICTORx.  The remaining samples
- * use PREDICTOR1.
- */
-
-#define DIFFERENCE_1D(INITIAL_PREDICTOR) \
-  lossless_comp_ptr losslessc = (lossless_comp_ptr)cinfo->fdct; \
-  boolean restart = FALSE; \
-  int samp, Ra; \
-  \
-  samp = *input_buf++; \
-  *diff_buf++ = samp - INITIAL_PREDICTOR; \
-  \
-  while (--width) { \
-    Ra = samp; \
-    samp = *input_buf++; \
-    *diff_buf++ = samp - PREDICTOR1; \
-  } \
-  \
-  /* Account for restart interval (no-op if not using restarts) */ \
-  if (cinfo->restart_interval) { \
-    if (--(losslessc->restart_rows_to_go[ci]) == 0) { \
-      reset_predictor(cinfo, ci); \
-      restart = TRUE; \
-    } \
-  }
-
-
-/*
- * 2-Dimensional differencer routine.
- *
- * This macro implements the 2-D horizontal predictors (#2-7).  PREDICTOR2 is
- * used as the special case predictor for the first column.  The remaining
- * samples use PREDICTOR, which is a function of Ra, Rb, and Rc.
- *
- * Because prev_row and output_buf may point to the same storage area (in an
- * interleaved image with Vi=1, for example), we must take care to buffer Rb/Rc
- * before writing the current reconstructed sample value into output_buf.
- */
-
-#define DIFFERENCE_2D(PREDICTOR) \
-  lossless_comp_ptr losslessc = (lossless_comp_ptr)cinfo->fdct; \
-  int samp, Ra, Rb, Rc; \
-  \
-  Rb = *prev_row++; \
-  samp = *input_buf++; \
-  *diff_buf++ = samp - PREDICTOR2; \
-  \
-  while (--width) { \
-    Rc = Rb; \
-    Rb = *prev_row++; \
-    Ra = samp; \
-    samp = *input_buf++; \
-    *diff_buf++ = samp - PREDICTOR; \
-  } \
-  \
-  /* Account for restart interval (no-op if not using restarts) */ \
-  if (cinfo->restart_interval) { \
-    if (--losslessc->restart_rows_to_go[ci] == 0) \
-      reset_predictor(cinfo, ci); \
-  }
-
-
-/*
- * Differencers for the second and subsequent rows in a scan or restart
- * interval.  The first sample in the row is differenced using the vertical
- * predictor (2).  The rest of the samples are differenced using the predictor
- * specified in the scan header.
- */
-
-METHODDEF(void)
-jpeg_difference1(j_compress_ptr cinfo, int ci,
-                 _JSAMPROW input_buf, _JSAMPROW prev_row,
-                 JDIFFROW diff_buf, JDIMENSION width)
-{
-  DIFFERENCE_1D(INITIAL_PREDICTOR2);
-  (void)(restart);
-}
-
-METHODDEF(void)
-jpeg_difference2(j_compress_ptr cinfo, int ci,
-                 _JSAMPROW input_buf, _JSAMPROW prev_row,
-                 JDIFFROW diff_buf, JDIMENSION width)
-{
-  DIFFERENCE_2D(PREDICTOR2);
-  (void)(Ra);
-  (void)(Rc);
-}
-
-METHODDEF(void)
-jpeg_difference3(j_compress_ptr cinfo, int ci,
-                 _JSAMPROW input_buf, _JSAMPROW prev_row,
-                 JDIFFROW diff_buf, JDIMENSION width)
-{
-  DIFFERENCE_2D(PREDICTOR3);
-  (void)(Ra);
-}
-
-METHODDEF(void)
-jpeg_difference4(j_compress_ptr cinfo, int ci,
-                 _JSAMPROW input_buf, _JSAMPROW prev_row,
-                 JDIFFROW diff_buf, JDIMENSION width)
-{
-  DIFFERENCE_2D(PREDICTOR4);
-}
-
-METHODDEF(void)
-jpeg_difference5(j_compress_ptr cinfo, int ci,
-                 _JSAMPROW input_buf, _JSAMPROW prev_row,
-                 JDIFFROW diff_buf, JDIMENSION width)
-{
-  DIFFERENCE_2D(PREDICTOR5);
-}
-
-METHODDEF(void)
-jpeg_difference6(j_compress_ptr cinfo, int ci,
-                 _JSAMPROW input_buf, _JSAMPROW prev_row,
-                 JDIFFROW diff_buf, JDIMENSION width)
-{
-  DIFFERENCE_2D(PREDICTOR6);
-}
-
-METHODDEF(void)
-jpeg_difference7(j_compress_ptr cinfo, int ci,
-                 _JSAMPROW input_buf, _JSAMPROW prev_row,
-                 JDIFFROW diff_buf, JDIMENSION width)
-{
-  DIFFERENCE_2D(PREDICTOR7);
-  (void)(Rc);
-}
-
-
-/*
- * Differencer for the first row in a scan or restart interval.  The first
- * sample in the row is differenced using the special predictor constant
- * x = 2 ^ (P-Pt-1).  The rest of the samples are differenced using the
- * 1-D horizontal predictor (1).
- */
-
-METHODDEF(void)
-jpeg_difference_first_row(j_compress_ptr cinfo, int ci,
-                          _JSAMPROW input_buf, _JSAMPROW prev_row,
-                          JDIFFROW diff_buf, JDIMENSION width)
-{
-  DIFFERENCE_1D(INITIAL_PREDICTORx);
-
-  /*
-   * Now that we have differenced the first row, we want to use the
-   * differencer that corresponds to the predictor specified in the
-   * scan header.
-   *
-   * Note that we don't do this if we have just reset the predictor
-   * for a new restart interval.
-   */
-  if (!restart) {
-    switch (cinfo->Ss) {
-    case 1:
-      losslessc->predict_difference[ci] = jpeg_difference1;
-      break;
-    case 2:
-      losslessc->predict_difference[ci] = jpeg_difference2;
-      break;
-    case 3:
-      losslessc->predict_difference[ci] = jpeg_difference3;
-      break;
-    case 4:
-      losslessc->predict_difference[ci] = jpeg_difference4;
-      break;
-    case 5:
-      losslessc->predict_difference[ci] = jpeg_difference5;
-      break;
-    case 6:
-      losslessc->predict_difference[ci] = jpeg_difference6;
-      break;
-    case 7:
-      losslessc->predict_difference[ci] = jpeg_difference7;
-      break;
-    }
-  }
-}
-
-/*
- * Reset predictor at the start of a pass or restart interval.
- */
-
-LOCAL(void)
-reset_predictor(j_compress_ptr cinfo, int ci)
-{
-  lossless_comp_ptr losslessc = (lossless_comp_ptr)cinfo->fdct;
-
-  /* Initialize restart counter */
-  losslessc->restart_rows_to_go[ci] =
-    cinfo->restart_interval / cinfo->MCUs_per_row;
-
-  /* Set difference function to first row function */
-  losslessc->predict_difference[ci] = jpeg_difference_first_row;
-}
-
-
-/********************** Sample downscaling by 2^Pt ***********************/
-
-METHODDEF(void)
-simple_downscale(j_compress_ptr cinfo,
-                 _JSAMPROW input_buf, _JSAMPROW output_buf, JDIMENSION width)
-{
-  do {
-    *output_buf++ = (_JSAMPLE)RIGHT_SHIFT(*input_buf++, cinfo->Al);
-  } while (--width);
-}
-
-
-METHODDEF(void)
-noscale(j_compress_ptr cinfo,
-        _JSAMPROW input_buf, _JSAMPROW output_buf, JDIMENSION width)
-{
-  memcpy(output_buf, input_buf, width * sizeof(_JSAMPLE));
-}
-
-
-/*
- * Initialize for a processing pass.
- */
-
-METHODDEF(void)
-start_pass_lossless(j_compress_ptr cinfo)
-{
-  lossless_comp_ptr losslessc = (lossless_comp_ptr)cinfo->fdct;
-  int ci;
-
-  /* Set scaler function based on Pt */
-  if (cinfo->Al)
-    losslessc->scaler_scale = simple_downscale;
-  else
-    losslessc->scaler_scale = noscale;
-
-  /* Check that the restart interval is an integer multiple of the number
-   * of MCUs in an MCU row.
-   */
-  if (cinfo->restart_interval % cinfo->MCUs_per_row != 0)
-    ERREXIT2(cinfo, JERR_BAD_RESTART,
-             cinfo->restart_interval, cinfo->MCUs_per_row);
-
-  /* Set predictors for start of pass */
-  for (ci = 0; ci < cinfo->num_components; ci++)
-    reset_predictor(cinfo, ci);
-}
-
-
-/*
- * Initialize the lossless compressor.
- */
-
-GLOBAL(void)
-_jinit_lossless_compressor(j_compress_ptr cinfo)
-{
-  lossless_comp_ptr losslessc;
-
-  /* Create subobject in permanent pool */
-  losslessc = (lossless_comp_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
-                                sizeof(jpeg_lossless_compressor));
-  cinfo->fdct = (struct jpeg_forward_dct *)losslessc;
-  losslessc->pub.start_pass = start_pass_lossless;
-}
-
-#endif /* C_LOSSLESS_SUPPORTED */
@@ -1,173 +0,0 @@
-/*
- * jcmainct.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1994-1996, Thomas G. Lane.
- * Lossless JPEG Modifications:
- * Copyright (C) 1999, Ken Murchison.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains the main buffer controller for compression.
- * The main buffer lies between the pre-processor and the JPEG
- * compressor proper; it holds downsampled data in the JPEG colorspace.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jsamplecomp.h"
-
-
-#if BITS_IN_JSAMPLE != 16 || defined(C_LOSSLESS_SUPPORTED)
-
-/* Private buffer controller object */
-
-typedef struct {
-  struct jpeg_c_main_controller pub; /* public fields */
-
-  JDIMENSION cur_iMCU_row;      /* number of current iMCU row */
-  JDIMENSION rowgroup_ctr;      /* counts row groups received in iMCU row */
-  boolean suspended;            /* remember if we suspended output */
-  J_BUF_MODE pass_mode;         /* current operating mode */
-
-  /* If using just a strip buffer, this points to the entire set of buffers
-   * (we allocate one for each component).  In the full-image case, this
-   * points to the currently accessible strips of the virtual arrays.
-   */
-  _JSAMPARRAY buffer[MAX_COMPONENTS];
-} my_main_controller;
-
-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);
-
-
-/*
- * Initialize for a processing pass.
- */
-
-METHODDEF(void)
-start_pass_main(j_compress_ptr cinfo, J_BUF_MODE pass_mode)
-{
-  my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
-
-  /* Do nothing in raw-data mode. */
-  if (cinfo->raw_data_in)
-    return;
-
-  if (pass_mode != JBUF_PASS_THRU)
-    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
-
-  main_ptr->cur_iMCU_row = 0;   /* initialize counters */
-  main_ptr->rowgroup_ctr = 0;
-  main_ptr->suspended = FALSE;
-  main_ptr->pass_mode = pass_mode;      /* save mode for use by process_data */
-  main_ptr->pub._process_data = process_data_simple_main;
-}
-
-
-/*
- * Process some data.
- * This routine handles the simple pass-through mode,
- * where we have only a strip buffer.
- */
-
-METHODDEF(void)
-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;
-  JDIMENSION data_unit = cinfo->master->lossless ? 1 : DCTSIZE;
-
-  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 < data_unit)
-      (*cinfo->prep->_pre_process_data) (cinfo, input_buf, in_row_ctr,
-                                         in_rows_avail, main_ptr->buffer,
-                                         &main_ptr->rowgroup_ctr, data_unit);
-
-    /* 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
-     * at the bottom of the image.
-     */
-    if (main_ptr->rowgroup_ctr != data_unit)
-      return;
-
-    /* Send the completed row to the compressor */
-    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) {
-        (*in_row_ctr)--;
-        main_ptr->suspended = TRUE;
-      }
-      return;
-    }
-    /* We did finish the row.  Undo our little suspension hack if a previous
-     * call suspended; then mark the main buffer empty.
-     */
-    if (main_ptr->suspended) {
-      (*in_row_ctr)++;
-      main_ptr->suspended = FALSE;
-    }
-    main_ptr->rowgroup_ctr = 0;
-    main_ptr->cur_iMCU_row++;
-  }
-}
-
-
-/*
- * Initialize main buffer controller.
- */
-
-GLOBAL(void)
-_jinit_c_main_controller(j_compress_ptr cinfo, boolean need_full_buffer)
-{
-  my_main_ptr main_ptr;
-  int ci;
-  jpeg_component_info *compptr;
-  int data_unit = cinfo->master->lossless ? 1 : DCTSIZE;
-
-  if (cinfo->data_precision != BITS_IN_JSAMPLE)
-    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-
-  main_ptr = (my_main_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                sizeof(my_main_controller));
-  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. */
-  if (cinfo->raw_data_in)
-    return;
-
-  /* Create the buffer.  It holds downsampled data, so each component
-   * may be of a different size.
-   */
-  if (need_full_buffer) {
-    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
-  } else {
-    /* Allocate a strip buffer for each component */
-    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-         ci++, compptr++) {
-      main_ptr->buffer[ci] = (_JSAMPARRAY)(*cinfo->mem->alloc_sarray)
-        ((j_common_ptr)cinfo, JPOOL_IMAGE,
-         compptr->width_in_blocks * data_unit,
-         (JDIMENSION)(compptr->v_samp_factor * data_unit));
-    }
-  }
-}
-
-#endif /* BITS_IN_JSAMPLE != 16 || defined(C_LOSSLESS_SUPPORTED) */
@@ -1,670 +0,0 @@
-/*
- * jcmarker.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1991-1998, Thomas G. Lane.
- * Modified 2003-2010 by Guido Vollbeding.
- * Lossless JPEG Modifications:
- * Copyright (C) 1999, Ken Murchison.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2010, 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains routines to write JPEG datastream markers.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jpegapicomp.h"
-
-
-typedef enum {                  /* JPEG marker codes */
-  M_SOF0  = 0xc0,
-  M_SOF1  = 0xc1,
-  M_SOF2  = 0xc2,
-  M_SOF3  = 0xc3,
-
-  M_SOF5  = 0xc5,
-  M_SOF6  = 0xc6,
-  M_SOF7  = 0xc7,
-
-  M_JPG   = 0xc8,
-  M_SOF9  = 0xc9,
-  M_SOF10 = 0xca,
-  M_SOF11 = 0xcb,
-
-  M_SOF13 = 0xcd,
-  M_SOF14 = 0xce,
-  M_SOF15 = 0xcf,
-
-  M_DHT   = 0xc4,
-
-  M_DAC   = 0xcc,
-
-  M_RST0  = 0xd0,
-  M_RST1  = 0xd1,
-  M_RST2  = 0xd2,
-  M_RST3  = 0xd3,
-  M_RST4  = 0xd4,
-  M_RST5  = 0xd5,
-  M_RST6  = 0xd6,
-  M_RST7  = 0xd7,
-
-  M_SOI   = 0xd8,
-  M_EOI   = 0xd9,
-  M_SOS   = 0xda,
-  M_DQT   = 0xdb,
-  M_DNL   = 0xdc,
-  M_DRI   = 0xdd,
-  M_DHP   = 0xde,
-  M_EXP   = 0xdf,
-
-  M_APP0  = 0xe0,
-  M_APP1  = 0xe1,
-  M_APP2  = 0xe2,
-  M_APP3  = 0xe3,
-  M_APP4  = 0xe4,
-  M_APP5  = 0xe5,
-  M_APP6  = 0xe6,
-  M_APP7  = 0xe7,
-  M_APP8  = 0xe8,
-  M_APP9  = 0xe9,
-  M_APP10 = 0xea,
-  M_APP11 = 0xeb,
-  M_APP12 = 0xec,
-  M_APP13 = 0xed,
-  M_APP14 = 0xee,
-  M_APP15 = 0xef,
-
-  M_JPG0  = 0xf0,
-  M_JPG13 = 0xfd,
-  M_COM   = 0xfe,
-
-  M_TEM   = 0x01,
-
-  M_ERROR = 0x100
-} JPEG_MARKER;
-
-
-/* Private state */
-
-typedef struct {
-  struct jpeg_marker_writer pub; /* public fields */
-
-  unsigned int last_restart_interval; /* last DRI value emitted; 0 after SOI */
-} my_marker_writer;
-
-typedef my_marker_writer *my_marker_ptr;
-
-
-/*
- * Basic output routines.
- *
- * Note that we do not support suspension while writing a marker.
- * Therefore, an application using suspension must ensure that there is
- * enough buffer space for the initial markers (typ. 600-700 bytes) before
- * calling jpeg_start_compress, and enough space to write the trailing EOI
- * (a few bytes) before calling jpeg_finish_compress.  Multipass compression
- * modes are not supported at all with suspension, so those two are the only
- * points where markers will be written.
- */
-
-LOCAL(void)
-emit_byte(j_compress_ptr cinfo, int val)
-/* Emit a byte */
-{
-  struct jpeg_destination_mgr *dest = cinfo->dest;
-
-  *(dest->next_output_byte)++ = (JOCTET)val;
-  if (--dest->free_in_buffer == 0) {
-    if (!(*dest->empty_output_buffer) (cinfo))
-      ERREXIT(cinfo, JERR_CANT_SUSPEND);
-  }
-}
-
-
-LOCAL(void)
-emit_marker(j_compress_ptr cinfo, JPEG_MARKER mark)
-/* Emit a marker code */
-{
-  emit_byte(cinfo, 0xFF);
-  emit_byte(cinfo, (int)mark);
-}
-
-
-LOCAL(void)
-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);
-  emit_byte(cinfo, value & 0xFF);
-}
-
-
-/*
- * Routines to write specific marker types.
- */
-
-LOCAL(int)
-emit_dqt(j_compress_ptr cinfo, int index)
-/* Emit a DQT marker */
-/* Returns the precision used (0 = 8bits, 1 = 16bits) for baseline checking */
-{
-  JQUANT_TBL *qtbl = cinfo->quant_tbl_ptrs[index];
-  int prec;
-  int i;
-
-  if (qtbl == NULL)
-    ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, index);
-
-  prec = 0;
-  for (i = 0; i < DCTSIZE2; i++) {
-    if (qtbl->quantval[i] > 255)
-      prec = 1;
-  }
-
-  if (!qtbl->sent_table) {
-    emit_marker(cinfo, M_DQT);
-
-    emit_2bytes(cinfo, prec ? DCTSIZE2 * 2 + 1 + 2 : DCTSIZE2 + 1 + 2);
-
-    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));
-    }
-
-    qtbl->sent_table = TRUE;
-  }
-
-  return prec;
-}
-
-
-LOCAL(void)
-emit_dht(j_compress_ptr cinfo, int index, boolean is_ac)
-/* Emit a DHT marker */
-{
-  JHUFF_TBL *htbl;
-  int length, i;
-
-  if (is_ac) {
-    htbl = cinfo->ac_huff_tbl_ptrs[index];
-    index += 0x10;              /* output index has AC bit set */
-  } else {
-    htbl = cinfo->dc_huff_tbl_ptrs[index];
-  }
-
-  if (htbl == NULL)
-    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, index);
-
-  if (!htbl->sent_table) {
-    emit_marker(cinfo, M_DHT);
-
-    length = 0;
-    for (i = 1; i <= 16; i++)
-      length += htbl->bits[i];
-
-    emit_2bytes(cinfo, length + 2 + 1 + 16);
-    emit_byte(cinfo, index);
-
-    for (i = 1; i <= 16; i++)
-      emit_byte(cinfo, htbl->bits[i]);
-
-    for (i = 0; i < length; i++)
-      emit_byte(cinfo, htbl->huffval[i]);
-
-    htbl->sent_table = TRUE;
-  }
-}
-
-
-LOCAL(void)
-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. */
-{
-#ifdef C_ARITH_CODING_SUPPORTED
-  char dc_in_use[NUM_ARITH_TBLS];
-  char ac_in_use[NUM_ARITH_TBLS];
-  int length, i;
-  jpeg_component_info *compptr;
-
-  for (i = 0; i < NUM_ARITH_TBLS; i++)
-    dc_in_use[i] = ac_in_use[i] = 0;
-
-  for (i = 0; i < cinfo->comps_in_scan; i++) {
-    compptr = cinfo->cur_comp_info[i];
-    /* DC needs no table for refinement scan */
-    if (cinfo->Ss == 0 && cinfo->Ah == 0)
-      dc_in_use[compptr->dc_tbl_no] = 1;
-    /* AC needs no table when not present */
-    if (cinfo->Se)
-      ac_in_use[compptr->ac_tbl_no] = 1;
-  }
-
-  length = 0;
-  for (i = 0; i < NUM_ARITH_TBLS; i++)
-    length += dc_in_use[i] + ac_in_use[i];
-
-  if (length) {
-    emit_marker(cinfo, M_DAC);
-
-    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));
-      }
-      if (ac_in_use[i]) {
-        emit_byte(cinfo, i + 0x10);
-        emit_byte(cinfo, cinfo->arith_ac_K[i]);
-      }
-    }
-  }
-#endif /* C_ARITH_CODING_SUPPORTED */
-}
-
-
-LOCAL(void)
-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);
-}
-
-
-LOCAL(void)
-emit_sof(j_compress_ptr cinfo, JPEG_MARKER code)
-/* Emit a SOF marker */
-{
-  int ci;
-  jpeg_component_info *compptr;
-
-  emit_marker(cinfo, 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);
-
-  emit_byte(cinfo, cinfo->data_precision);
-  emit_2bytes(cinfo, (int)cinfo->_jpeg_height);
-  emit_2bytes(cinfo, (int)cinfo->_jpeg_width);
-
-  emit_byte(cinfo, cinfo->num_components);
-
-  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-       ci++, compptr++) {
-    emit_byte(cinfo, compptr->component_id);
-    emit_byte(cinfo, (compptr->h_samp_factor << 4) + compptr->v_samp_factor);
-    emit_byte(cinfo, compptr->quant_tbl_no);
-  }
-}
-
-
-LOCAL(void)
-emit_sos(j_compress_ptr cinfo)
-/* Emit a SOS marker */
-{
-  int i, td, ta;
-  jpeg_component_info *compptr;
-
-  emit_marker(cinfo, M_SOS);
-
-  emit_2bytes(cinfo, 2 * cinfo->comps_in_scan + 2 + 1 + 3); /* length */
-
-  emit_byte(cinfo, cinfo->comps_in_scan);
-
-  for (i = 0; i < cinfo->comps_in_scan; i++) {
-    compptr = cinfo->cur_comp_info[i];
-    emit_byte(cinfo, compptr->component_id);
-
-    /* We emit 0 for unused field(s); this is recommended by the P&M text
-     * but does not seem to be specified in the standard.
-     */
-
-    /* DC needs no table for refinement scan */
-    td = cinfo->Ss == 0 && cinfo->Ah == 0 ? compptr->dc_tbl_no : 0;
-    /* AC needs no table when not present */
-    ta = cinfo->Se ? compptr->ac_tbl_no : 0;
-
-    emit_byte(cinfo, (td << 4) + ta);
-  }
-
-  emit_byte(cinfo, cinfo->Ss);
-  emit_byte(cinfo, cinfo->Se);
-  emit_byte(cinfo, (cinfo->Ah << 4) + cinfo->Al);
-}
-
-
-LOCAL(void)
-emit_jfif_app0(j_compress_ptr cinfo)
-/* Emit a JFIF-compliant APP0 marker */
-{
-  /*
-   * Length of APP0 block       (2 bytes)
-   * Block ID                   (4 bytes - ASCII "JFIF")
-   * Zero byte                  (1 byte to terminate the ID string)
-   * Version Major, Minor       (2 bytes - major first)
-   * Units                      (1 byte - 0x00 = none, 0x01 = inch, 0x02 = cm)
-   * Xdpu                       (2 bytes - dots per unit horizontal)
-   * Ydpu                       (2 bytes - dots per unit vertical)
-   * Thumbnail X size           (1 byte)
-   * Thumbnail Y size           (1 byte)
-   */
-
-  emit_marker(cinfo, M_APP0);
-
-  emit_2bytes(cinfo, 2 + 4 + 1 + 2 + 1 + 2 + 2 + 1 + 1); /* length */
-
-  emit_byte(cinfo, 0x4A);       /* Identifier: ASCII "JFIF" */
-  emit_byte(cinfo, 0x46);
-  emit_byte(cinfo, 0x49);
-  emit_byte(cinfo, 0x46);
-  emit_byte(cinfo, 0);
-  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_byte(cinfo, 0);          /* No thumbnail image */
-  emit_byte(cinfo, 0);
-}
-
-
-LOCAL(void)
-emit_adobe_app14(j_compress_ptr cinfo)
-/* Emit an Adobe APP14 marker */
-{
-  /*
-   * Length of APP14 block      (2 bytes)
-   * Block ID                   (5 bytes - ASCII "Adobe")
-   * Version Number             (2 bytes - currently 100)
-   * Flags0                     (2 bytes - currently 0)
-   * Flags1                     (2 bytes - currently 0)
-   * Color transform            (1 byte)
-   *
-   * Although Adobe TN 5116 mentions Version = 101, all the Adobe files
-   * now in circulation seem to use Version = 100, so that's what we write.
-   *
-   * We write the color transform byte as 1 if the JPEG color space is
-   * YCbCr, 2 if it's YCCK, 0 otherwise.  Adobe's definition has to do with
-   * whether the encoder performed a transformation, which is pretty useless.
-   */
-
-  emit_marker(cinfo, M_APP14);
-
-  emit_2bytes(cinfo, 2 + 5 + 2 + 2 + 2 + 1); /* length */
-
-  emit_byte(cinfo, 0x41);       /* Identifier: ASCII "Adobe" */
-  emit_byte(cinfo, 0x64);
-  emit_byte(cinfo, 0x6F);
-  emit_byte(cinfo, 0x62);
-  emit_byte(cinfo, 0x65);
-  emit_2bytes(cinfo, 100);      /* Version */
-  emit_2bytes(cinfo, 0);        /* Flags0 */
-  emit_2bytes(cinfo, 0);        /* Flags1 */
-  switch (cinfo->jpeg_color_space) {
-  case JCS_YCbCr:
-    emit_byte(cinfo, 1);        /* Color transform = 1 */
-    break;
-  case JCS_YCCK:
-    emit_byte(cinfo, 2);        /* Color transform = 2 */
-    break;
-  default:
-    emit_byte(cinfo, 0);        /* Color transform = 0 */
-    break;
-  }
-}
-
-
-/*
- * These routines allow writing an arbitrary marker with parameters.
- * The only intended use is to emit COM or APPn markers after calling
- * write_file_header and before calling write_frame_header.
- * Other uses are not guaranteed to produce desirable results.
- * Counting the parameter bytes properly is the caller's responsibility.
- */
-
-METHODDEF(void)
-write_marker_header(j_compress_ptr cinfo, int marker, unsigned int datalen)
-/* Emit an arbitrary marker header */
-{
-  if (datalen > (unsigned int)65533)            /* safety check */
-    ERREXIT(cinfo, JERR_BAD_LENGTH);
-
-  emit_marker(cinfo, (JPEG_MARKER)marker);
-
-  emit_2bytes(cinfo, (int)(datalen + 2));       /* total length */
-}
-
-METHODDEF(void)
-write_marker_byte(j_compress_ptr cinfo, int val)
-/* Emit one byte of marker parameters following write_marker_header */
-{
-  emit_byte(cinfo, val);
-}
-
-
-/*
- * Write datastream header.
- * This consists of an SOI and optional APPn markers.
- * We recommend use of the JFIF marker, but not the Adobe marker,
- * when using YCbCr or grayscale data.  The JFIF marker should NOT
- * be used for any other JPEG colorspace.  The Adobe marker is helpful
- * to distinguish RGB, CMYK, and YCCK colorspaces.
- * Note that an application can write additional header markers after
- * jpeg_start_compress returns.
- */
-
-METHODDEF(void)
-write_file_header(j_compress_ptr cinfo)
-{
-  my_marker_ptr marker = (my_marker_ptr)cinfo->marker;
-
-  emit_marker(cinfo, M_SOI);    /* first the SOI */
-
-  /* SOI is defined to reset restart interval to 0 */
-  marker->last_restart_interval = 0;
-
-  if (cinfo->write_JFIF_header) /* next an optional JFIF APP0 */
-    emit_jfif_app0(cinfo);
-  if (cinfo->write_Adobe_marker) /* next an optional Adobe APP14 */
-    emit_adobe_app14(cinfo);
-}
-
-
-/*
- * Write frame header.
- * This consists of DQT and SOFn markers.
- * Note that we do not emit the SOF until we have emitted the DQT(s).
- * This avoids compatibility problems with incorrect implementations that
- * try to error-check the quant table numbers as soon as they see the SOF.
- */
-
-METHODDEF(void)
-write_frame_header(j_compress_ptr cinfo)
-{
-  int ci, prec = 0;
-  boolean is_baseline;
-  jpeg_component_info *compptr;
-
-  if (!cinfo->master->lossless) {
-    /* Emit DQT for each quantization table.
-     * Note that emit_dqt() suppresses any duplicate tables.
-     */
-    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-         ci++, compptr++) {
-      prec += emit_dqt(cinfo, compptr->quant_tbl_no);
-    }
-    /* now prec is nonzero iff there are any 16-bit quant tables. */
-  }
-
-  /* Check for a non-baseline specification.
-   * Note we assume that Huffman table numbers won't be changed later.
-   */
-  if (cinfo->arith_code || cinfo->progressive_mode ||
-      cinfo->master->lossless || cinfo->data_precision != 8) {
-    is_baseline = FALSE;
-  } else {
-    is_baseline = TRUE;
-    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-         ci++, compptr++) {
-      if (compptr->dc_tbl_no > 1 || compptr->ac_tbl_no > 1)
-        is_baseline = FALSE;
-    }
-    if (prec && is_baseline) {
-      is_baseline = FALSE;
-      /* If it's baseline except for quantizer size, warn the user */
-      TRACEMS(cinfo, 0, JTRC_16BIT_TABLES);
-    }
-  }
-
-  /* Emit the proper SOF marker */
-  if (cinfo->arith_code) {
-    if (cinfo->progressive_mode)
-      emit_sof(cinfo, M_SOF10); /* SOF code for progressive arithmetic */
-    else
-      emit_sof(cinfo, M_SOF9);  /* SOF code for sequential arithmetic */
-  } else {
-    if (cinfo->progressive_mode)
-      emit_sof(cinfo, M_SOF2);  /* SOF code for progressive Huffman */
-    else if (cinfo->master->lossless)
-      emit_sof(cinfo, M_SOF3);  /* SOF code for lossless Huffman */
-    else if (is_baseline)
-      emit_sof(cinfo, M_SOF0);  /* SOF code for baseline implementation */
-    else
-      emit_sof(cinfo, M_SOF1);  /* SOF code for non-baseline Huffman file */
-  }
-}
-
-
-/*
- * Write scan header.
- * This consists of DHT or DAC markers, optional DRI, and SOS.
- * Compressed data will be written following the SOS.
- */
-
-METHODDEF(void)
-write_scan_header(j_compress_ptr cinfo)
-{
-  my_marker_ptr marker = (my_marker_ptr)cinfo->marker;
-  int i;
-  jpeg_component_info *compptr;
-
-  if (cinfo->arith_code) {
-    /* Emit arith conditioning info.  We may have some duplication
-     * if the file has multiple scans, but it's so small it's hardly
-     * worth worrying about.
-     */
-    emit_dac(cinfo);
-  } else {
-    /* Emit Huffman tables.
-     * Note that emit_dht() suppresses any duplicate tables.
-     */
-    for (i = 0; i < cinfo->comps_in_scan; i++) {
-      compptr = cinfo->cur_comp_info[i];
-      /* DC needs no table for refinement scan */
-      if ((cinfo->Ss == 0 && cinfo->Ah == 0) || cinfo->master->lossless)
-        emit_dht(cinfo, compptr->dc_tbl_no, FALSE);
-      /* AC needs no table when not present, and lossless mode uses only DC
-         tables. */
-      if (cinfo->Se && !cinfo->master->lossless)
-        emit_dht(cinfo, compptr->ac_tbl_no, TRUE);
-    }
-  }
-
-  /* Emit DRI if required --- note that DRI value could change for each scan.
-   * We avoid wasting space with unnecessary DRIs, however.
-   */
-  if (cinfo->restart_interval != marker->last_restart_interval) {
-    emit_dri(cinfo);
-    marker->last_restart_interval = cinfo->restart_interval;
-  }
-
-  emit_sos(cinfo);
-}
-
-
-/*
- * Write datastream trailer.
- */
-
-METHODDEF(void)
-write_file_trailer(j_compress_ptr cinfo)
-{
-  emit_marker(cinfo, M_EOI);
-}
-
-
-/*
- * Write an abbreviated table-specification datastream.
- * This consists of SOI, DQT and DHT tables, and EOI.
- * Any table that is defined and not marked sent_table = TRUE will be
- * emitted.  Note that all tables will be marked sent_table = TRUE at exit.
- */
-
-METHODDEF(void)
-write_tables_only(j_compress_ptr cinfo)
-{
-  int i;
-
-  emit_marker(cinfo, M_SOI);
-
-  for (i = 0; i < NUM_QUANT_TBLS; i++) {
-    if (cinfo->quant_tbl_ptrs[i] != NULL)
-      (void)emit_dqt(cinfo, i);
-  }
-
-  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);
-      if (cinfo->ac_huff_tbl_ptrs[i] != NULL)
-        emit_dht(cinfo, i, TRUE);
-    }
-  }
-
-  emit_marker(cinfo, M_EOI);
-}
-
-
-/*
- * Initialize the marker writer module.
- */
-
-GLOBAL(void)
-jinit_marker_writer(j_compress_ptr cinfo)
-{
-  my_marker_ptr marker;
-
-  /* Create the subobject */
-  marker = (my_marker_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                sizeof(my_marker_writer));
-  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;
-  marker->pub.write_scan_header = write_scan_header;
-  marker->pub.write_file_trailer = write_file_trailer;
-  marker->pub.write_tables_only = write_tables_only;
-  marker->pub.write_marker_header = write_marker_header;
-  marker->pub.write_marker_byte = write_marker_byte;
-  /* Initialize private state */
-  marker->last_restart_interval = 0;
-}
@@ -1,793 +0,0 @@
-/*
- * jcmaster.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1991-1997, Thomas G. Lane.
- * Modified 2003-2010 by Guido Vollbeding.
- * Lossless JPEG Modifications:
- * Copyright (C) 1999, Ken Murchison.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2010, 2016, 2018, 2022-2024, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains master control logic for the JPEG compressor.
- * These routines are concerned with parameter validation, initial setup,
- * and inter-pass control (determining the number of passes and the work
- * to be done in each pass).
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jpegapicomp.h"
-#include "jcmaster.h"
-
-
-/*
- * Support routines that do various essential calculations.
- */
-
-#if JPEG_LIB_VERSION >= 70
-/*
- * Compute JPEG image dimensions and related values.
- * NOTE: this is exported for possible use by application.
- * Hence it mustn't do anything that can't be done twice.
- */
-
-GLOBAL(void)
-jpeg_calc_jpeg_dimensions(j_compress_ptr cinfo)
-/* Do computations that are needed before master selection phase */
-{
-  int data_unit = cinfo->master->lossless ? 1 : DCTSIZE;
-
-  /* Hardwire it to "no scaling" */
-  cinfo->jpeg_width = cinfo->image_width;
-  cinfo->jpeg_height = cinfo->image_height;
-  cinfo->min_DCT_h_scaled_size = data_unit;
-  cinfo->min_DCT_v_scaled_size = data_unit;
-}
-#endif
-
-
-LOCAL(boolean)
-using_std_huff_tables(j_compress_ptr cinfo)
-{
-  int i;
-
-  static const UINT8 bits_dc_luminance[17] = {
-    /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0
-  };
-  static const UINT8 val_dc_luminance[] = {
-    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
-  };
-
-  static const UINT8 bits_dc_chrominance[17] = {
-    /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0
-  };
-  static const UINT8 val_dc_chrominance[] = {
-    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
-  };
-
-  static const UINT8 bits_ac_luminance[17] = {
-    /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d
-  };
-  static const UINT8 val_ac_luminance[] = {
-    0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
-    0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
-    0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
-    0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
-    0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
-    0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
-    0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
-    0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
-    0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
-    0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
-    0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
-    0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
-    0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
-    0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
-    0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
-    0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
-    0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
-    0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
-    0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
-    0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
-    0xf9, 0xfa
-  };
-
-  static const UINT8 bits_ac_chrominance[17] = {
-    /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77
-  };
-  static const UINT8 val_ac_chrominance[] = {
-    0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
-    0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
-    0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
-    0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
-    0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
-    0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
-    0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
-    0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
-    0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
-    0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
-    0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
-    0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
-    0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
-    0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
-    0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
-    0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
-    0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
-    0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
-    0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
-    0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
-    0xf9, 0xfa
-  };
-
-  if (cinfo->dc_huff_tbl_ptrs[0] == NULL ||
-      cinfo->ac_huff_tbl_ptrs[0] == NULL ||
-      cinfo->dc_huff_tbl_ptrs[1] == NULL ||
-      cinfo->ac_huff_tbl_ptrs[1] == NULL)
-    return FALSE;
-
-  for (i = 2; i < NUM_HUFF_TBLS; i++) {
-    if (cinfo->dc_huff_tbl_ptrs[i] != NULL ||
-        cinfo->ac_huff_tbl_ptrs[i] != NULL)
-      return FALSE;
-  }
-
-  if (memcmp(cinfo->dc_huff_tbl_ptrs[0]->bits, bits_dc_luminance,
-             sizeof(bits_dc_luminance)) ||
-      memcmp(cinfo->dc_huff_tbl_ptrs[0]->huffval, val_dc_luminance,
-             sizeof(val_dc_luminance)) ||
-      memcmp(cinfo->ac_huff_tbl_ptrs[0]->bits, bits_ac_luminance,
-             sizeof(bits_ac_luminance)) ||
-      memcmp(cinfo->ac_huff_tbl_ptrs[0]->huffval, val_ac_luminance,
-             sizeof(val_ac_luminance)) ||
-      memcmp(cinfo->dc_huff_tbl_ptrs[1]->bits, bits_dc_chrominance,
-             sizeof(bits_dc_chrominance)) ||
-      memcmp(cinfo->dc_huff_tbl_ptrs[1]->huffval, val_dc_chrominance,
-             sizeof(val_dc_chrominance)) ||
-      memcmp(cinfo->ac_huff_tbl_ptrs[1]->bits, bits_ac_chrominance,
-             sizeof(bits_ac_chrominance)) ||
-      memcmp(cinfo->ac_huff_tbl_ptrs[1]->huffval, val_ac_chrominance,
-             sizeof(val_ac_chrominance)))
-    return FALSE;
-
-  return TRUE;
-}
-
-
-LOCAL(void)
-initial_setup(j_compress_ptr cinfo, boolean transcode_only)
-/* Do computations that are needed before master selection phase */
-{
-  int ci;
-  jpeg_component_info *compptr;
-  long samplesperrow;
-  JDIMENSION jd_samplesperrow;
-  int data_unit = cinfo->master->lossless ? 1 : DCTSIZE;
-
-#if JPEG_LIB_VERSION >= 70
-#if JPEG_LIB_VERSION >= 80
-  if (!transcode_only)
-#endif
-    jpeg_calc_jpeg_dimensions(cinfo);
-#endif
-
-  /* Sanity check on image dimensions */
-  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);
-
-  /* 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)
-    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
-
-#ifdef C_LOSSLESS_SUPPORTED
-  if (cinfo->data_precision != 8 && cinfo->data_precision != 12 &&
-      cinfo->data_precision != 16)
-#else
-  if (cinfo->data_precision != 8 && cinfo->data_precision != 12)
-#endif
-    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-
-  /* Check that number of components won't exceed internal array sizes */
-  if (cinfo->num_components > MAX_COMPONENTS)
-    ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
-             MAX_COMPONENTS);
-
-  /* Compute maximum sampling factors; check factor validity */
-  cinfo->max_h_samp_factor = 1;
-  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)
-      ERREXIT(cinfo, JERR_BAD_SAMPLING);
-    cinfo->max_h_samp_factor = MAX(cinfo->max_h_samp_factor,
-                                   compptr->h_samp_factor);
-    cinfo->max_v_samp_factor = MAX(cinfo->max_v_samp_factor,
-                                   compptr->v_samp_factor);
-  }
-
-  /* Compute dimensions of components */
-  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-       ci++, compptr++) {
-    /* Fill in the correct component_index value; don't rely on application */
-    compptr->component_index = ci;
-    /* For compression, we never do DCT scaling. */
-#if JPEG_LIB_VERSION >= 70
-    compptr->DCT_h_scaled_size = compptr->DCT_v_scaled_size = data_unit;
-#else
-    compptr->DCT_scaled_size = data_unit;
-#endif
-    /* Size in data units */
-    compptr->width_in_blocks = (JDIMENSION)
-      jdiv_round_up((long)cinfo->_jpeg_width * (long)compptr->h_samp_factor,
-                    (long)(cinfo->max_h_samp_factor * data_unit));
-    compptr->height_in_blocks = (JDIMENSION)
-      jdiv_round_up((long)cinfo->_jpeg_height * (long)compptr->v_samp_factor,
-                    (long)(cinfo->max_v_samp_factor * data_unit));
-    /* 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);
-    compptr->downsampled_height = (JDIMENSION)
-      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;
-  }
-
-  /* Compute number of fully interleaved MCU rows (number of times that
-   * main controller will call coefficient or difference controller).
-   */
-  cinfo->total_iMCU_rows = (JDIMENSION)
-    jdiv_round_up((long)cinfo->_jpeg_height,
-                  (long)(cinfo->max_v_samp_factor * data_unit));
-}
-
-
-#if defined(C_MULTISCAN_FILES_SUPPORTED) || defined(C_LOSSLESS_SUPPORTED)
-#define NEED_SCAN_SCRIPT
-#endif
-
-#ifdef NEED_SCAN_SCRIPT
-
-LOCAL(void)
-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.
- */
-{
-  const jpeg_scan_info *scanptr;
-  int scanno, ncomps, ci, coefi, thisi;
-  int Ss, Se, Ah, Al;
-  boolean component_sent[MAX_COMPONENTS];
-#ifdef C_PROGRESSIVE_SUPPORTED
-  int *last_bitpos_ptr;
-  int last_bitpos[MAX_COMPONENTS][DCTSIZE2];
-  /* -1 until that coefficient has been seen; then last Al for it */
-#endif
-
-  if (cinfo->num_scans <= 0)
-    ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, 0);
-
-#ifndef C_MULTISCAN_FILES_SUPPORTED
-  if (cinfo->num_scans > 1)
-    ERREXIT(cinfo, JERR_NOT_COMPILED);
-#endif
-
-  scanptr = cinfo->scan_info;
-  if (scanptr->Ss != 0 && scanptr->Se == 0) {
-#ifdef C_LOSSLESS_SUPPORTED
-    cinfo->master->lossless = TRUE;
-    cinfo->progressive_mode = FALSE;
-    for (ci = 0; ci < cinfo->num_components; ci++)
-      component_sent[ci] = FALSE;
-#else
-    ERREXIT(cinfo, JERR_NOT_COMPILED);
-#endif
-  }
-  /* For sequential JPEG, all scans must have Ss=0, Se=DCTSIZE2-1;
-   * for progressive JPEG, no scan can have this.
-   */
-  else if (scanptr->Ss != 0 || scanptr->Se != DCTSIZE2 - 1) {
-#ifdef C_PROGRESSIVE_SUPPORTED
-    cinfo->progressive_mode = TRUE;
-    cinfo->master->lossless = FALSE;
-    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;
-#else
-    ERREXIT(cinfo, JERR_NOT_COMPILED);
-#endif
-  } else {
-    cinfo->progressive_mode = cinfo->master->lossless = FALSE;
-    for (ci = 0; ci < cinfo->num_components; ci++)
-      component_sent[ci] = FALSE;
-  }
-
-  for (scanno = 1; scanno <= cinfo->num_scans; scanptr++, scanno++) {
-    /* Validate component indexes */
-    ncomps = scanptr->comps_in_scan;
-    if (ncomps <= 0 || ncomps > MAX_COMPS_IN_SCAN)
-      ERREXIT2(cinfo, JERR_COMPONENT_COUNT, ncomps, MAX_COMPS_IN_SCAN);
-    for (ci = 0; ci < ncomps; ci++) {
-      thisi = scanptr->component_index[ci];
-      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])
-        ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno);
-    }
-    /* Validate progression parameters */
-    Ss = scanptr->Ss;
-    Se = scanptr->Se;
-    Ah = scanptr->Ah;
-    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.
-       * 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.
-       */
-      int max_Ah_Al = cinfo->data_precision == 12 ? 13 : 10;
-
-      if (Ss < 0 || Ss >= DCTSIZE2 || Se < Ss || Se >= DCTSIZE2 ||
-          Ah < 0 || Ah > max_Ah_Al || Al < 0 || Al > max_Ah_Al)
-        ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
-      if (Ss == 0) {
-        if (Se != 0)            /* DC and AC together not OK */
-          ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
-      } else {
-        if (ncomps != 1)        /* AC scans must be for only one component */
-          ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
-      }
-      for (ci = 0; ci < ncomps; ci++) {
-        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++) {
-          if (last_bitpos_ptr[coefi] < 0) {
-            /* first scan of this coefficient */
-            if (Ah != 0)
-              ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
-          } else {
-            /* not first scan */
-            if (Ah != last_bitpos_ptr[coefi] || Al != Ah - 1)
-              ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
-          }
-          last_bitpos_ptr[coefi] = Al;
-        }
-      }
-#endif
-    } else {
-#ifdef C_LOSSLESS_SUPPORTED
-      if (cinfo->master->lossless) {
-        /* The JPEG spec simply gives the range 0..15 for Al (Pt), but that
-         * seems wrong: the upper bound ought to depend on data precision.
-         * Perhaps they really meant 0..N-1 for N-bit precision, which is what
-         * we allow here.  Values greater than or equal to the data precision
-         * will result in a blank image.
-         */
-        if (Ss < 1 || Ss > 7 ||         /* predictor selection value */
-            Se != 0 || Ah != 0 ||
-            Al < 0 || Al >= cinfo->data_precision) /* point transform */
-          ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
-      } else
-#endif
-      {
-        /* For sequential JPEG, all progression parameters must be these: */
-        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++) {
-        thisi = scanptr->component_index[ci];
-        if (component_sent[thisi])
-          ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno);
-        component_sent[thisi] = TRUE;
-      }
-    }
-  }
-
-  /* Now verify that everything got sent. */
-  if (cinfo->progressive_mode) {
-#ifdef C_PROGRESSIVE_SUPPORTED
-    /* For progressive mode, we only check that at least some DC data
-     * got sent for each component; the spec does not require that all bits
-     * of all coefficients be transmitted.  Would it be wiser to enforce
-     * transmission of all coefficient bits??
-     */
-    for (ci = 0; ci < cinfo->num_components; ci++) {
-      if (last_bitpos[ci][0] < 0)
-        ERREXIT(cinfo, JERR_MISSING_DATA);
-    }
-#endif
-  } else {
-    for (ci = 0; ci < cinfo->num_components; ci++) {
-      if (!component_sent[ci])
-        ERREXIT(cinfo, JERR_MISSING_DATA);
-    }
-  }
-}
-
-#endif /* NEED_SCAN_SCRIPT */
-
-
-LOCAL(void)
-select_scan_parameters(j_compress_ptr cinfo)
-/* Set up the scan parameters for the current scan */
-{
-  int ci;
-
-#ifdef NEED_SCAN_SCRIPT
-  if (cinfo->scan_info != NULL) {
-    /* Prepare for current scan --- the script is already validated */
-    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;
-    for (ci = 0; ci < scanptr->comps_in_scan; ci++) {
-      cinfo->cur_comp_info[ci] =
-        &cinfo->comp_info[scanptr->component_index[ci]];
-    }
-    cinfo->Ss = scanptr->Ss;
-    cinfo->Se = scanptr->Se;
-    cinfo->Ah = scanptr->Ah;
-    cinfo->Al = scanptr->Al;
-  } else
-#endif
-  {
-    /* Prepare for single sequential-JPEG scan containing all components */
-    if (cinfo->num_components > MAX_COMPS_IN_SCAN)
-      ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
-               MAX_COMPS_IN_SCAN);
-    cinfo->comps_in_scan = cinfo->num_components;
-    for (ci = 0; ci < cinfo->num_components; ci++) {
-      cinfo->cur_comp_info[ci] = &cinfo->comp_info[ci];
-    }
-    if (!cinfo->master->lossless) {
-      cinfo->Ss = 0;
-      cinfo->Se = DCTSIZE2 - 1;
-      cinfo->Ah = 0;
-      cinfo->Al = 0;
-    }
-  }
-}
-
-
-LOCAL(void)
-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 */
-{
-  int ci, mcublks, tmp;
-  jpeg_component_info *compptr;
-  int data_unit = cinfo->master->lossless ? 1 : DCTSIZE;
-
-  if (cinfo->comps_in_scan == 1) {
-
-    /* Noninterleaved (single-component) scan */
-    compptr = cinfo->cur_comp_info[0];
-
-    /* Overall image size in MCUs */
-    cinfo->MCUs_per_row = compptr->width_in_blocks;
-    cinfo->MCU_rows_in_scan = compptr->height_in_blocks;
-
-    /* For noninterleaved scan, always one block per MCU */
-    compptr->MCU_width = 1;
-    compptr->MCU_height = 1;
-    compptr->MCU_blocks = 1;
-    compptr->MCU_sample_width = data_unit;
-    compptr->last_col_width = 1;
-    /* 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);
-    if (tmp == 0) tmp = compptr->v_samp_factor;
-    compptr->last_row_height = tmp;
-
-    /* Prepare array describing MCU composition */
-    cinfo->blocks_in_MCU = 1;
-    cinfo->MCU_membership[0] = 0;
-
-  } else {
-
-    /* Interleaved (multi-component) scan */
-    if (cinfo->comps_in_scan <= 0 || cinfo->comps_in_scan > MAX_COMPS_IN_SCAN)
-      ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->comps_in_scan,
-               MAX_COMPS_IN_SCAN);
-
-    /* Overall image size in MCUs */
-    cinfo->MCUs_per_row = (JDIMENSION)
-      jdiv_round_up((long)cinfo->_jpeg_width,
-                    (long)(cinfo->max_h_samp_factor * data_unit));
-    cinfo->MCU_rows_in_scan = (JDIMENSION)
-      jdiv_round_up((long)cinfo->_jpeg_height,
-                    (long)(cinfo->max_v_samp_factor * data_unit));
-
-    cinfo->blocks_in_MCU = 0;
-
-    for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
-      compptr = cinfo->cur_comp_info[ci];
-      /* Sampling factors give # of blocks of component in each MCU */
-      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 * data_unit;
-      /* Figure number of non-dummy blocks in last MCU column & row */
-      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);
-      if (tmp == 0) tmp = compptr->MCU_height;
-      compptr->last_row_height = tmp;
-      /* Prepare array describing MCU composition */
-      mcublks = compptr->MCU_blocks;
-      if (cinfo->blocks_in_MCU + mcublks > C_MAX_BLOCKS_IN_MCU)
-        ERREXIT(cinfo, JERR_BAD_MCU_SIZE);
-      while (mcublks-- > 0) {
-        cinfo->MCU_membership[cinfo->blocks_in_MCU++] = ci;
-      }
-    }
-
-  }
-
-  /* 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);
-  }
-}
-
-
-/*
- * Per-pass setup.
- * This is called at the beginning of each pass.  We determine which modules
- * will be active during this pass and give them appropriate start_pass calls.
- * We also set is_last_pass to indicate whether any more passes will be
- * required.
- */
-
-METHODDEF(void)
-prepare_for_pass(j_compress_ptr cinfo)
-{
-  my_master_ptr master = (my_master_ptr)cinfo->master;
-
-  switch (master->pass_type) {
-  case main_pass:
-    /* Initial pass: will collect input data, and do either Huffman
-     * optimization or data output for the first scan.
-     */
-    select_scan_parameters(cinfo);
-    per_scan_setup(cinfo);
-    if (!cinfo->raw_data_in) {
-      (*cinfo->cconvert->start_pass) (cinfo);
-      (*cinfo->downsample->start_pass) (cinfo);
-      (*cinfo->prep->start_pass) (cinfo, JBUF_PASS_THRU);
-    }
-    (*cinfo->fdct->start_pass) (cinfo);
-    (*cinfo->entropy->start_pass) (cinfo, cinfo->optimize_coding);
-    (*cinfo->coef->start_pass) (cinfo,
-                                (master->total_passes > 1 ?
-                                 JBUF_SAVE_AND_PASS : JBUF_PASS_THRU));
-    (*cinfo->main->start_pass) (cinfo, JBUF_PASS_THRU);
-    if (cinfo->optimize_coding) {
-      /* No immediate data output; postpone writing frame/scan headers */
-      master->pub.call_pass_startup = FALSE;
-    } else {
-      /* Will write frame/scan headers at first jpeg_write_scanlines call */
-      master->pub.call_pass_startup = TRUE;
-    }
-    break;
-#ifdef ENTROPY_OPT_SUPPORTED
-  case huff_opt_pass:
-    /* Do Huffman optimization for a scan after the first one. */
-    select_scan_parameters(cinfo);
-    per_scan_setup(cinfo);
-    if (cinfo->Ss != 0 || cinfo->Ah == 0 || cinfo->arith_code ||
-        cinfo->master->lossless) {
-      (*cinfo->entropy->start_pass) (cinfo, TRUE);
-      (*cinfo->coef->start_pass) (cinfo, JBUF_CRANK_DEST);
-      master->pub.call_pass_startup = FALSE;
-      break;
-    }
-    /* Special case: Huffman DC refinement scans need no Huffman table
-     * and therefore we can skip the optimization pass for them.
-     */
-    master->pass_type = output_pass;
-    master->pass_number++;
-#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) {
-      select_scan_parameters(cinfo);
-      per_scan_setup(cinfo);
-    }
-    (*cinfo->entropy->start_pass) (cinfo, FALSE);
-    (*cinfo->coef->start_pass) (cinfo, JBUF_CRANK_DEST);
-    /* We emit frame/scan headers now */
-    if (master->scan_number == 0)
-      (*cinfo->marker->write_frame_header) (cinfo);
-    (*cinfo->marker->write_scan_header) (cinfo);
-    master->pub.call_pass_startup = FALSE;
-    break;
-  default:
-    ERREXIT(cinfo, JERR_NOT_COMPILED);
-  }
-
-  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) {
-    cinfo->progress->completed_passes = master->pass_number;
-    cinfo->progress->total_passes = master->total_passes;
-  }
-}
-
-
-/*
- * Special start-of-pass hook.
- * This is called by jpeg_write_scanlines if call_pass_startup is TRUE.
- * In single-pass processing, we need this hook because we don't want to
- * write frame/scan headers during jpeg_start_compress; we want to let the
- * application write COM markers etc. between jpeg_start_compress and the
- * jpeg_write_scanlines loop.
- * In multi-pass processing, this routine is not used.
- */
-
-METHODDEF(void)
-pass_startup(j_compress_ptr cinfo)
-{
-  cinfo->master->call_pass_startup = FALSE; /* reset flag so call only once */
-
-  (*cinfo->marker->write_frame_header) (cinfo);
-  (*cinfo->marker->write_scan_header) (cinfo);
-}
-
-
-/*
- * Finish up at end of pass.
- */
-
-METHODDEF(void)
-finish_pass_master(j_compress_ptr cinfo)
-{
-  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.
-   */
-  (*cinfo->entropy->finish_pass) (cinfo);
-
-  /* Update state for next pass */
-  switch (master->pass_type) {
-  case main_pass:
-    /* next pass is either output of scan 0 (after optimization)
-     * or output of scan 1 (if no optimization).
-     */
-    master->pass_type = output_pass;
-    if (!cinfo->optimize_coding)
-      master->scan_number++;
-    break;
-  case huff_opt_pass:
-    /* next pass is always output of current scan */
-    master->pass_type = output_pass;
-    break;
-  case output_pass:
-    /* next pass is either optimization or output of next scan */
-    if (cinfo->optimize_coding)
-      master->pass_type = huff_opt_pass;
-    master->scan_number++;
-    break;
-  }
-
-  master->pass_number++;
-}
-
-
-/*
- * Initialize master compression control.
- */
-
-GLOBAL(void)
-jinit_c_master_control(j_compress_ptr cinfo, boolean transcode_only)
-{
-  my_master_ptr master = (my_master_ptr)cinfo->master;
-  boolean empty_huff_tables = TRUE;
-  int i;
-
-  master->pub.prepare_for_pass = prepare_for_pass;
-  master->pub.pass_startup = pass_startup;
-  master->pub.finish_pass = finish_pass_master;
-  master->pub.is_last_pass = FALSE;
-
-  if (cinfo->scan_info != NULL) {
-#ifdef NEED_SCAN_SCRIPT
-    validate_script(cinfo);
-#else
-    ERREXIT(cinfo, JERR_NOT_COMPILED);
-#endif
-  } else {
-    cinfo->progressive_mode = FALSE;
-    cinfo->num_scans = 1;
-  }
-
-  /* Disable smoothing and subsampling in lossless mode, since those are lossy
-   * algorithms.  Set the JPEG colorspace to the input colorspace.  Disable raw
-   * (downsampled) data input, because it isn't particularly useful without
-   * subsampling and has not been tested in lossless mode.
-   */
-  if (cinfo->master->lossless) {
-    int ci;
-    jpeg_component_info *compptr;
-
-    cinfo->raw_data_in = FALSE;
-    cinfo->smoothing_factor = 0;
-    jpeg_default_colorspace(cinfo);
-    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-         ci++, compptr++)
-      compptr->h_samp_factor = compptr->v_samp_factor = 1;
-  }
-
-  /* Validate parameters, determine derived values */
-  initial_setup(cinfo, transcode_only);
-
-  if (cinfo->arith_code)
-    cinfo->optimize_coding = FALSE;
-  else {
-    if (cinfo->master->lossless ||      /*  TEMPORARY HACK ??? */
-        cinfo->progressive_mode)
-      cinfo->optimize_coding = TRUE; /* assume default tables no good for
-                                        progressive mode or lossless mode */
-    for (i = 0; i < NUM_HUFF_TBLS; i++) {
-      if (cinfo->dc_huff_tbl_ptrs[i] != NULL ||
-          cinfo->ac_huff_tbl_ptrs[i] != NULL) {
-        empty_huff_tables = FALSE;
-        break;
-      }
-    }
-    if (cinfo->data_precision == 12 && !cinfo->optimize_coding &&
-        (empty_huff_tables || using_std_huff_tables(cinfo)))
-      cinfo->optimize_coding = TRUE; /* assume default tables no good for
-                                        12-bit data precision */
-  }
-
-  /* Initialize my private state */
-  if (transcode_only) {
-    /* no main pass in transcoding */
-    if (cinfo->optimize_coding)
-      master->pass_type = huff_opt_pass;
-    else
-      master->pass_type = output_pass;
-  } else {
-    /* for normal compression, first pass is always this type: */
-    master->pass_type = main_pass;
-  }
-  master->scan_number = 0;
-  master->pass_number = 0;
-  if (cinfo->optimize_coding)
-    master->total_passes = cinfo->num_scans * 2;
-  else
-    master->total_passes = cinfo->num_scans;
-
-  master->jpeg_version = PACKAGE_NAME " version " VERSION " (build " BUILD ")";
-}
@@ -1,43 +0,0 @@
-/*
- * jcmaster.h
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1991-1995, Thomas G. Lane.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2016, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains master control structure for the JPEG compressor.
- */
-
-/* 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 */
-} c_pass_type;
-
-typedef struct {
-  struct jpeg_comp_master pub;  /* public fields */
-
-  c_pass_type pass_type;        /* the type of the current pass */
-
-  int pass_number;              /* # of passes completed */
-  int total_passes;             /* total # of passes needed */
-
-  int scan_number;              /* current index in scan_info[] */
-
-  /*
-   * This is here so we can add libjpeg-turbo version/build information to the
-   * global string table without introducing a new global symbol.  Adding this
-   * information to the global string table allows one to examine a binary
-   * object and determine which version of libjpeg-turbo it was built from or
-   * linked against.
-   */
-  const char *jpeg_version;
-
-} my_comp_master;
-
-typedef my_comp_master *my_master_ptr;
@@ -1,110 +0,0 @@
-/*
- * jcomapi.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1994-1997, Thomas G. Lane.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2024, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains application interface routines that are used for both
- * compression and decompression.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-
-
-/*
- * Abort processing of a JPEG compression or decompression operation,
- * but don't destroy the object itself.
- *
- * For this, we merely clean up all the nonpermanent memory pools.
- * Note that temp files (virtual arrays) are not allowed to belong to
- * the permanent pool, so we will be able to close all temp files here.
- * Closing a data source or destination, if necessary, is the application's
- * responsibility.
- */
-
-GLOBAL(void)
-jpeg_abort(j_common_ptr cinfo)
-{
-  int pool;
-
-  /* Do nothing if called on a not-initialized or destroyed JPEG object. */
-  if (cinfo->mem == NULL)
-    return;
-
-  /* Releasing pools in reverse order might help avoid fragmentation
-   * with some (brain-damaged) malloc libraries.
-   */
-  for (pool = JPOOL_NUMPOOLS - 1; pool > JPOOL_PERMANENT; pool--) {
-    (*cinfo->mem->free_pool) (cinfo, pool);
-  }
-
-  /* Reset overall state for possible reuse of object */
-  if (cinfo->is_decompressor) {
-    cinfo->global_state = DSTATE_START;
-    /* 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)->master->marker_list_end = NULL;
-  } else {
-    cinfo->global_state = CSTATE_START;
-  }
-}
-
-
-/*
- * Destruction of a JPEG object.
- *
- * Everything gets deallocated except the master jpeg_compress_struct itself
- * and the error manager struct.  Both of these are supplied by the application
- * and must be freed, if necessary, by the application.  (Often they are on
- * the stack and so don't need to be freed anyway.)
- * Closing a data source or destination, if necessary, is the application's
- * responsibility.
- */
-
-GLOBAL(void)
-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. */
-  if (cinfo->mem != NULL)
-    (*cinfo->mem->self_destruct) (cinfo);
-  cinfo->mem = NULL;            /* be safe if jpeg_destroy is called twice */
-  cinfo->global_state = 0;      /* mark it destroyed */
-}
-
-
-/*
- * Convenience routines for allocating quantization and Huffman tables.
- * (Would jutils.c be a more reasonable place to put these?)
- */
-
-GLOBAL(JQUANT_TBL *)
-jpeg_alloc_quant_table(j_common_ptr cinfo)
-{
-  JQUANT_TBL *tbl;
-
-  tbl = (JQUANT_TBL *)
-    (*cinfo->mem->alloc_small) (cinfo, JPOOL_PERMANENT, sizeof(JQUANT_TBL));
-  tbl->sent_table = FALSE;      /* make sure this is false in any new table */
-  return tbl;
-}
-
-
-GLOBAL(JHUFF_TBL *)
-jpeg_alloc_huff_table(j_common_ptr cinfo)
-{
-  JHUFF_TBL *tbl;
-
-  tbl = (JHUFF_TBL *)
-    (*cinfo->mem->alloc_small) (cinfo, JPOOL_PERMANENT, sizeof(JHUFF_TBL));
-  tbl->sent_table = FALSE;      /* make sure this is false in any new table */
-  return tbl;
-}
@@ -1,60 +0,0 @@
-/* Version ID for the JPEG library.
- * Might be useful for tests like "#if JPEG_LIB_VERSION >= 60".
- */
-#define JPEG_LIB_VERSION  @JPEG_LIB_VERSION@
-
-/* 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 when using 8-bit samples */
-#cmakedefine C_ARITH_CODING_SUPPORTED 1
-
-/* Support arithmetic decoding when using 8-bit samples */
-#cmakedefine D_ARITH_CODING_SUPPORTED 1
-
-/* Support in-memory source/destination managers */
-#define MEM_SRCDST_SUPPORTED  1
-
-/* Use accelerated SIMD routines when using 8-bit samples */
-#cmakedefine WITH_SIMD 1
-
-/* This version of libjpeg-turbo supports run-time selection of data precision,
- * so BITS_IN_JSAMPLE is no longer used to specify the data precision at build
- * time.  However, some downstream software expects the macro to be defined.
- * Since 12-bit data precision is an opt-in feature that requires explicitly
- * calling 12-bit-specific libjpeg API functions and using 12-bit-specific data
- * types, the unmodified portion of the libjpeg API still behaves as if it were
- * built for 8-bit precision, and JSAMPLE is still literally an 8-bit data
- * type.  Thus, it is correct to define BITS_IN_JSAMPLE to 8 here.
- */
-#ifndef BITS_IN_JSAMPLE
-#define BITS_IN_JSAMPLE  8
-#endif
-
-#ifdef _WIN32
-
-#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 */
-
-#else
-
-/* Define if your (broken) compiler shifts signed values as if they were
-   unsigned. */
-#cmakedefine RIGHT_SHIFT_IS_UNSIGNED 1
-
-#endif
@@ -1,76 +0,0 @@
-/* libjpeg-turbo build number */
-#define BUILD  "@BUILD@"
-
-/* How to hide global symbols. */
-#define HIDDEN  @HIDDEN@
-
-/* Compiler's inline keyword */
-#undef inline
-
-/* How to obtain function inlining. */
-#define INLINE  @INLINE@
-
-/* 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  @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
-
-/*
- * Define BITS_IN_JSAMPLE as either
- *   8   for 8-bit sample values (the usual setting)
- *   12  for 12-bit sample values
- * Only 8 and 12 are legal data precisions for lossy JPEG according to the
- * JPEG standard, and the IJG code does not support anything else!
- */
-
-#ifndef BITS_IN_JSAMPLE
-#define BITS_IN_JSAMPLE  8      /* use 8 or 12 */
-#endif
-
-#undef C_ARITH_CODING_SUPPORTED
-#undef D_ARITH_CODING_SUPPORTED
-#undef WITH_SIMD
-
-#if BITS_IN_JSAMPLE == 8
-
-/* Support arithmetic encoding */
-#cmakedefine C_ARITH_CODING_SUPPORTED 1
-
-/* Support arithmetic decoding */
-#cmakedefine D_ARITH_CODING_SUPPORTED 1
-
-/* Use accelerated SIMD routines. */
-#cmakedefine WITH_SIMD 1
-
-#endif
@@ -1,585 +0,0 @@
-/*
- * jcparam.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1991-1998, Thomas G. Lane.
- * Modified 2003-2008 by Guido Vollbeding.
- * Lossless JPEG Modifications:
- * Copyright (C) 1999, Ken Murchison.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2009-2011, 2018, 2023, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains optional default-setting code for the JPEG compressor.
- * Applications do not have to use this file, but those that don't use it
- * must know a lot more about the innards of the JPEG code.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jstdhuff.c"
-
-
-/*
- * Quantization table setup routines
- */
-
-GLOBAL(void)
-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
- * are limited to 1..255 for JPEG baseline compatibility.
- */
-{
-  JQUANT_TBL **qtblptr;
-  int i;
-  long temp;
-
-  /* Safety check to ensure start_compress not called yet. */
-  if (cinfo->global_state != CSTATE_START)
-    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
-
-  if (which_tbl < 0 || which_tbl >= NUM_QUANT_TBLS)
-    ERREXIT1(cinfo, JERR_DQT_INDEX, which_tbl);
-
-  qtblptr = &cinfo->quant_tbl_ptrs[which_tbl];
-
-  if (*qtblptr == NULL)
-    *qtblptr = jpeg_alloc_quant_table((j_common_ptr)cinfo);
-
-  for (i = 0; i < DCTSIZE2; i++) {
-    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;
-  }
-
-  /* Initialize sent_table FALSE so table will be written to JPEG file. */
-  (*qtblptr)->sent_table = FALSE;
-}
-
-
-/* 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.
- * The spec says that the values given produce "good" quality, and
- * when divided by 2, "very good" quality.
- */
-static const unsigned int std_luminance_quant_tbl[DCTSIZE2] = {
-  16,  11,  10,  16,  24,  40,  51,  61,
-  12,  12,  14,  19,  26,  58,  60,  55,
-  14,  13,  16,  24,  40,  57,  69,  56,
-  14,  17,  22,  29,  51,  87,  80,  62,
-  18,  22,  37,  56,  68, 109, 103,  77,
-  24,  35,  55,  64,  81, 104, 113,  92,
-  49,  64,  78,  87, 103, 121, 120, 101,
-  72,  92,  95,  98, 112, 100, 103,  99
-};
-static const unsigned int std_chrominance_quant_tbl[DCTSIZE2] = {
-  17,  18,  24,  47,  99,  99,  99,  99,
-  18,  21,  26,  66,  99,  99,  99,  99,
-  24,  26,  56,  99,  99,  99,  99,  99,
-  47,  66,  99,  99,  99,  99,  99,  99,
-  99,  99,  99,  99,  99,  99,  99,  99,
-  99,  99,  99,  99,  99,  99,  99,  99,
-  99,  99,  99,  99,  99,  99,  99,  99,
-  99,  99,  99,  99,  99,  99,  99,  99
-};
-
-
-#if JPEG_LIB_VERSION >= 70
-GLOBAL(void)
-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.
- */
-{
-  /* Set up two quantization tables using the specified scaling */
-  jpeg_add_quant_table(cinfo, 0, std_luminance_quant_tbl,
-                       cinfo->q_scale_factor[0], force_baseline);
-  jpeg_add_quant_table(cinfo, 1, std_chrominance_quant_tbl,
-                       cinfo->q_scale_factor[1], force_baseline);
-}
-#endif
-
-
-GLOBAL(void)
-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
- * applications that insist on a linear percentage scaling.
- */
-{
-  /* Set up two quantization tables using the specified scaling */
-  jpeg_add_quant_table(cinfo, 0, std_luminance_quant_tbl,
-                       scale_factor, force_baseline);
-  jpeg_add_quant_table(cinfo, 1, std_chrominance_quant_tbl,
-                       scale_factor, force_baseline);
-}
-
-
-GLOBAL(int)
-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).
- */
-{
-  /* Safety limit on quality factor.  Convert 0 to 1 to avoid zero divide. */
-  if (quality <= 0) quality = 1;
-  if (quality > 100) quality = 100;
-
-  /* The basic table is used as-is (scaling 100) for a quality of 50.
-   * Qualities 50..100 are converted to scaling percentage 200 - 2*Q;
-   * note that at Q=100 the scaling is 0, which will cause jpeg_add_quant_table
-   * to make all the table entries 1 (hence, minimum quantization loss).
-   * Qualities 1..50 are converted to scaling percentage 5000/Q.
-   */
-  if (quality < 50)
-    quality = 5000 / quality;
-  else
-    quality = 200 - quality * 2;
-
-  return quality;
-}
-
-
-GLOBAL(void)
-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
- * would use the preceding three routines directly.
- */
-{
-  /* Convert user 0-100 rating to percentage scaling */
-  quality = jpeg_quality_scaling(quality);
-
-  /* Set up standard quality tables */
-  jpeg_set_linear_quality(cinfo, quality, force_baseline);
-}
-
-
-/*
- * Default parameter setup for compression.
- *
- * Applications that don't choose to use this routine must do their
- * own setup of all these parameters.  Alternately, you can call this
- * to establish defaults and then alter parameters selectively.  This
- * is the recommended approach since, if we add any new parameters,
- * your code will still work (they'll be set to reasonable defaults).
- */
-
-GLOBAL(void)
-jpeg_set_defaults(j_compress_ptr cinfo)
-{
-  int i;
-
-  /* Safety check to ensure start_compress not called yet. */
-  if (cinfo->global_state != CSTATE_START)
-    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
-
-  /* Allocate comp_info array large enough for maximum component count.
-   * Array is made permanent in case application wants to compress
-   * multiple images at same param settings.
-   */
-  if (cinfo->comp_info == NULL)
-    cinfo->comp_info = (jpeg_component_info *)
-      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
-                                  MAX_COMPONENTS * sizeof(jpeg_component_info));
-
-  /* Initialize everything not dependent on the color space */
-
-#if JPEG_LIB_VERSION >= 70
-  cinfo->scale_num = 1;         /* 1:1 scaling */
-  cinfo->scale_denom = 1;
-#endif
-  /* 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);
-
-  /* Initialize default arithmetic coding conditioning */
-  for (i = 0; i < NUM_ARITH_TBLS; i++) {
-    cinfo->arith_dc_L[i] = 0;
-    cinfo->arith_dc_U[i] = 1;
-    cinfo->arith_ac_K[i] = 5;
-  }
-
-  /* Default is no multiple-scan output */
-  cinfo->scan_info = NULL;
-  cinfo->num_scans = 0;
-
-  /* Expect normal source image, not raw downsampled data */
-  cinfo->raw_data_in = FALSE;
-
-  /* Use Huffman coding, not arithmetic coding, by default */
-  cinfo->arith_code = FALSE;
-
-  /* By default, don't do extra passes to optimize entropy coding */
-  cinfo->optimize_coding = FALSE;
-  /* The standard Huffman tables are only valid for 8-bit data precision.
-   * If the precision is higher, force optimization on so that usable
-   * tables will be computed.  This test can be removed if default tables
-   * are supplied that are valid for the desired precision.
-   */
-  if (cinfo->data_precision == 12)
-    cinfo->optimize_coding = TRUE;
-
-  /* By default, use the simpler non-cosited sampling alignment */
-  cinfo->CCIR601_sampling = FALSE;
-
-#if JPEG_LIB_VERSION >= 70
-  /* By default, apply fancy downsampling */
-  cinfo->do_fancy_downsampling = TRUE;
-#endif
-
-  /* No input smoothing */
-  cinfo->smoothing_factor = 0;
-
-  /* DCT algorithm preference */
-  cinfo->dct_method = JDCT_DEFAULT;
-
-  /* No restart markers */
-  cinfo->restart_interval = 0;
-  cinfo->restart_in_rows = 0;
-
-  /* Fill in default JFIF marker parameters.  Note that whether the marker
-   * will actually be written is determined by jpeg_set_colorspace.
-   *
-   * By default, the library emits JFIF version code 1.01.
-   * An application that wants to emit JFIF 1.02 extension markers should set
-   * JFIF_minor_version to 2.  We could probably get away with just defaulting
-   * to 1.02, but there may still be some decoders in use that will complain
-   * about that; saying 1.01 should minimize compatibility problems.
-   */
-  cinfo->JFIF_major_version = 1; /* Default JFIF version = 1.01 */
-  cinfo->JFIF_minor_version = 1;
-  cinfo->density_unit = 0;      /* Pixel size is unknown by default */
-  cinfo->X_density = 1;         /* Pixel aspect ratio is square by default */
-  cinfo->Y_density = 1;
-
-  /* Choose JPEG colorspace based on input space, set defaults accordingly */
-
-  jpeg_default_colorspace(cinfo);
-}
-
-
-/*
- * Select an appropriate JPEG colorspace for in_color_space.
- */
-
-GLOBAL(void)
-jpeg_default_colorspace(j_compress_ptr cinfo)
-{
-  switch (cinfo->in_color_space) {
-  case JCS_GRAYSCALE:
-    jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
-    break;
-  case JCS_RGB:
-  case JCS_EXT_RGB:
-  case JCS_EXT_RGBX:
-  case JCS_EXT_BGR:
-  case JCS_EXT_BGRX:
-  case JCS_EXT_XBGR:
-  case JCS_EXT_XRGB:
-  case JCS_EXT_RGBA:
-  case JCS_EXT_BGRA:
-  case JCS_EXT_ABGR:
-  case JCS_EXT_ARGB:
-    if (cinfo->master->lossless)
-      jpeg_set_colorspace(cinfo, JCS_RGB);
-    else
-      jpeg_set_colorspace(cinfo, JCS_YCbCr);
-    break;
-  case JCS_YCbCr:
-    jpeg_set_colorspace(cinfo, JCS_YCbCr);
-    break;
-  case JCS_CMYK:
-    jpeg_set_colorspace(cinfo, JCS_CMYK); /* By default, no translation */
-    break;
-  case JCS_YCCK:
-    jpeg_set_colorspace(cinfo, JCS_YCCK);
-    break;
-  case JCS_UNKNOWN:
-    jpeg_set_colorspace(cinfo, JCS_UNKNOWN);
-    break;
-  default:
-    ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
-  }
-}
-
-
-/*
- * Set the JPEG colorspace, and choose colorspace-dependent default values.
- */
-
-GLOBAL(void)
-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) \
-  (compptr = &cinfo->comp_info[index], \
-   compptr->component_id = (id), \
-   compptr->h_samp_factor = (hsamp), \
-   compptr->v_samp_factor = (vsamp), \
-   compptr->quant_tbl_no = (quant), \
-   compptr->dc_tbl_no = (dctbl), \
-   compptr->ac_tbl_no = (actbl) )
-
-  /* Safety check to ensure start_compress not called yet. */
-  if (cinfo->global_state != CSTATE_START)
-    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
-
-  /* For all colorspaces, we use Q and Huff tables 0 for luminance components,
-   * tables 1 for chrominance components.
-   */
-
-  cinfo->jpeg_color_space = colorspace;
-
-  cinfo->write_JFIF_header = FALSE; /* No marker for non-JFIF colorspaces */
-  cinfo->write_Adobe_marker = FALSE; /* write no Adobe marker by default */
-
-  switch (colorspace) {
-  case JCS_GRAYSCALE:
-    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);
-    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);
-    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);
-    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);
-    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);
-    break;
-  case JCS_UNKNOWN:
-    cinfo->num_components = cinfo->input_components;
-    if (cinfo->num_components < 1 || cinfo->num_components > MAX_COMPONENTS)
-      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);
-    }
-    break;
-  default:
-    ERREXIT(cinfo, JERR_BAD_J_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)
-/* Support routine: generate one scan for specified component */
-{
-  scanptr->comps_in_scan = 1;
-  scanptr->component_index[0] = ci;
-  scanptr->Ss = Ss;
-  scanptr->Se = Se;
-  scanptr->Ah = Ah;
-  scanptr->Al = Al;
-  scanptr++;
-  return scanptr;
-}
-
-LOCAL(jpeg_scan_info *)
-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;
-
-  for (ci = 0; ci < ncomps; ci++) {
-    scanptr->comps_in_scan = 1;
-    scanptr->component_index[0] = ci;
-    scanptr->Ss = Ss;
-    scanptr->Se = Se;
-    scanptr->Ah = Ah;
-    scanptr->Al = Al;
-    scanptr++;
-  }
-  return scanptr;
-}
-
-LOCAL(jpeg_scan_info *)
-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;
-
-  if (ncomps <= MAX_COMPS_IN_SCAN) {
-    /* Single interleaved DC scan */
-    scanptr->comps_in_scan = ncomps;
-    for (ci = 0; ci < ncomps; ci++)
-      scanptr->component_index[ci] = ci;
-    scanptr->Ss = scanptr->Se = 0;
-    scanptr->Ah = Ah;
-    scanptr->Al = Al;
-    scanptr++;
-  } else {
-    /* Noninterleaved DC scan for each component */
-    scanptr = fill_scans(scanptr, ncomps, 0, 0, Ah, Al);
-  }
-  return scanptr;
-}
-
-
-/*
- * Create a recommended progressive-JPEG script.
- * cinfo->num_components and cinfo->jpeg_color_space must be correct.
- */
-
-GLOBAL(void)
-jpeg_simple_progression(j_compress_ptr cinfo)
-{
-  int ncomps = cinfo->num_components;
-  int nscans;
-  jpeg_scan_info *scanptr;
-
-  /* Safety check to ensure start_compress not called yet. */
-  if (cinfo->global_state != CSTATE_START)
-    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
-
-  if (cinfo->master->lossless) {
-    cinfo->master->lossless = FALSE;
-    jpeg_default_colorspace(cinfo);
-  }
-
-  /* Figure space needed for script.  Calculation must match code below! */
-  if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
-    /* Custom script for YCbCr color images. */
-    nscans = 10;
-  } else {
-    /* All-purpose script for other color spaces. */
-    if (ncomps > MAX_COMPS_IN_SCAN)
-      nscans = 6 * ncomps;      /* 2 DC + 4 AC scans per component */
-    else
-      nscans = 2 + 4 * ncomps;  /* 2 DC scans; 4 AC scans per component */
-  }
-
-  /* Allocate space for script.
-   * We need to put it in the permanent pool in case the application performs
-   * multiple compressions without changing the settings.  To avoid a memory
-   * leak if jpeg_simple_progression is called repeatedly for the same JPEG
-   * object, we try to re-use previously allocated space, and we allocate
-   * enough space to handle YCbCr even if initially asked for grayscale.
-   */
-  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->script_space_size * sizeof(jpeg_scan_info));
-  }
-  scanptr = cinfo->script_space;
-  cinfo->scan_info = scanptr;
-  cinfo->num_scans = nscans;
-
-  if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
-    /* Custom script for YCbCr color images. */
-    /* Initial DC scan */
-    scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
-    /* Initial AC scan: get some luma data out in a hurry */
-    scanptr = fill_a_scan(scanptr, 0, 1, 5, 0, 2);
-    /* Chroma data is too small to be worth expending many scans on */
-    scanptr = fill_a_scan(scanptr, 2, 1, 63, 0, 1);
-    scanptr = fill_a_scan(scanptr, 1, 1, 63, 0, 1);
-    /* Complete spectral selection for luma AC */
-    scanptr = fill_a_scan(scanptr, 0, 6, 63, 0, 2);
-    /* Refine next bit of luma AC */
-    scanptr = fill_a_scan(scanptr, 0, 1, 63, 2, 1);
-    /* Finish DC successive approximation */
-    scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
-    /* Finish AC successive approximation */
-    scanptr = fill_a_scan(scanptr, 2, 1, 63, 1, 0);
-    scanptr = fill_a_scan(scanptr, 1, 1, 63, 1, 0);
-    /* Luma bottom bit comes last since it's usually largest scan */
-    scanptr = fill_a_scan(scanptr, 0, 1, 63, 1, 0);
-  } else {
-    /* All-purpose script for other color spaces. */
-    /* Successive approximation first pass */
-    scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
-    scanptr = fill_scans(scanptr, ncomps, 1, 5, 0, 2);
-    scanptr = fill_scans(scanptr, ncomps, 6, 63, 0, 2);
-    /* Successive approximation second pass */
-    scanptr = fill_scans(scanptr, ncomps, 1, 63, 2, 1);
-    /* Successive approximation final pass */
-    scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
-    scanptr = fill_scans(scanptr, ncomps, 1, 63, 1, 0);
-  }
-}
-
-#endif /* C_PROGRESSIVE_SUPPORTED */
-
-
-#ifdef C_LOSSLESS_SUPPORTED
-
-/*
- * Enable lossless mode.
- */
-
-GLOBAL(void)
-jpeg_enable_lossless(j_compress_ptr cinfo, int predictor_selection_value,
-                     int point_transform)
-{
-  /* Safety check to ensure start_compress not called yet. */
-  if (cinfo->global_state != CSTATE_START)
-    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
-
-  cinfo->master->lossless = TRUE;
-  cinfo->Ss = predictor_selection_value;
-  cinfo->Se = 0;
-  cinfo->Ah = 0;
-  cinfo->Al = point_transform;
-
-  /* The JPEG spec simply gives the range 0..15 for Al (Pt), but that seems
-   * wrong: the upper bound ought to depend on data precision.  Perhaps they
-   * really meant 0..N-1 for N-bit precision, which is what we allow here.
-   * Values greater than or equal to the data precision will result in a blank
-   * image.
-   */
-  if (cinfo->Ss < 1 || cinfo->Ss > 7 ||
-      cinfo->Al < 0 || cinfo->Al >= cinfo->data_precision)
-    ERREXIT4(cinfo, JERR_BAD_PROGRESSION,
-             cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al);
-}
-
-#endif /* C_LOSSLESS_SUPPORTED */
@@ -1,365 +0,0 @@
-/*
- * jcprepct.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1994-1996, Thomas G. Lane.
- * Lossless JPEG Modifications:
- * Copyright (C) 1999, Ken Murchison.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains the compression preprocessing controller.
- * This controller manages the color conversion, downsampling,
- * and edge expansion steps.
- *
- * Most of the complexity here is associated with buffering input rows
- * as required by the downsampler.  See the comments at the head of
- * jcsample.c for the downsampler's needs.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jsamplecomp.h"
-
-
-#if BITS_IN_JSAMPLE != 16 || defined(C_LOSSLESS_SUPPORTED)
-
-/* At present, jcsample.c can request context rows only for smoothing.
- * In the future, we might also need context rows for CCIR601 sampling
- * or other more-complex downsampling procedures.  The code to support
- * context rows should be compiled only if needed.
- */
-#ifdef INPUT_SMOOTHING_SUPPORTED
-#define CONTEXT_ROWS_SUPPORTED
-#endif
-
-
-/*
- * For the simple (no-context-row) case, we just need to buffer one
- * row group's worth of pixels for the downsampling step.  At the bottom of
- * the image, we pad to a full row group by replicating the last pixel row.
- * The downsampler's last output row is then replicated if needed to pad
- * out to a full iMCU row.
- *
- * When providing context rows, we must buffer three row groups' worth of
- * pixels.  Three row groups are physically allocated, but the row pointer
- * arrays are made five row groups high, with the extra pointers above and
- * below "wrapping around" to point to the last and first real row groups.
- * This allows the downsampler to access the proper context rows.
- * At the top and bottom of the image, we create dummy context rows by
- * copying the first or last real pixel row.  This copying could be avoided
- * by pointer hacking as is done in jdmainct.c, but it doesn't seem worth the
- * trouble on the compression side.
- */
-
-
-/* Private buffer controller object */
-
-typedef struct {
-  struct jpeg_c_prep_controller pub; /* public fields */
-
-  /* Downsampling input buffer.  This buffer holds color-converted data
-   * until we have enough to do a downsample step.
-   */
-  _JSAMPARRAY color_buf[MAX_COMPONENTS];
-
-  JDIMENSION rows_to_go;        /* counts rows remaining in source image */
-  int next_buf_row;             /* index of next row to store in color_buf */
-
-#ifdef CONTEXT_ROWS_SUPPORTED   /* only needed for context case */
-  int this_row_group;           /* starting row index of group to process */
-  int next_buf_stop;            /* downsample when we reach this index */
-#endif
-} my_prep_controller;
-
-typedef my_prep_controller *my_prep_ptr;
-
-
-/*
- * Initialize for a processing pass.
- */
-
-METHODDEF(void)
-start_pass_prep(j_compress_ptr cinfo, J_BUF_MODE pass_mode)
-{
-  my_prep_ptr prep = (my_prep_ptr)cinfo->prep;
-
-  if (pass_mode != JBUF_PASS_THRU)
-    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
-
-  /* Initialize total-height counter for detecting bottom of image */
-  prep->rows_to_go = cinfo->image_height;
-  /* Mark the conversion buffer empty */
-  prep->next_buf_row = 0;
-#ifdef CONTEXT_ROWS_SUPPORTED
-  /* Preset additional state variables for context mode.
-   * These aren't used in non-context mode, so we needn't test which mode.
-   */
-  prep->this_row_group = 0;
-  /* Set next_buf_stop to stop after two row groups have been read in. */
-  prep->next_buf_stop = 2 * cinfo->max_v_samp_factor;
-#endif
-}
-
-
-/*
- * Expand an image vertically from height input_rows to height output_rows,
- * by duplicating the bottom row.
- */
-
-LOCAL(void)
-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);
-  }
-}
-
-
-/*
- * Process some data in the simple no-context case.
- *
- * Preprocessor output data is counted in "row groups".  A row group
- * is defined to be v_samp_factor sample rows of each component.
- * Downsampling will produce this much data from each max_v_samp_factor
- * 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)
-{
-  my_prep_ptr prep = (my_prep_ptr)cinfo->prep;
-  int numrows, ci;
-  JDIMENSION inrows;
-  jpeg_component_info *compptr;
-  int data_unit = cinfo->master->lossless ? 1 : DCTSIZE;
-
-  while (*in_row_ctr < in_rows_avail &&
-         *out_row_group_ctr < out_row_groups_avail) {
-    /* 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);
-    (*cinfo->cconvert->_color_convert) (cinfo, input_buf + *in_row_ctr,
-                                        prep->color_buf,
-                                        (JDIMENSION)prep->next_buf_row,
-                                        numrows);
-    *in_row_ctr += numrows;
-    prep->next_buf_row += numrows;
-    prep->rows_to_go -= numrows;
-    /* If at bottom of image, pad to fill the conversion buffer. */
-    if (prep->rows_to_go == 0 &&
-        prep->next_buf_row < cinfo->max_v_samp_factor) {
-      for (ci = 0; ci < cinfo->num_components; ci++) {
-        expand_bottom_edge(prep->color_buf[ci], cinfo->image_width,
-                           prep->next_buf_row, cinfo->max_v_samp_factor);
-      }
-      prep->next_buf_row = cinfo->max_v_samp_factor;
-    }
-    /* 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,
-                                         output_buf, *out_row_group_ctr);
-      prep->next_buf_row = 0;
-      (*out_row_group_ctr)++;
-    }
-    /* 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) {
-      for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-           ci++, compptr++) {
-        expand_bottom_edge(output_buf[ci],
-                           compptr->width_in_blocks * data_unit,
-                           (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 */
-    }
-  }
-}
-
-
-#ifdef CONTEXT_ROWS_SUPPORTED
-
-/*
- * Process some data in the context case.
- */
-
-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)
-{
-  my_prep_ptr prep = (my_prep_ptr)cinfo->prep;
-  int numrows, ci;
-  int buf_height = cinfo->max_v_samp_factor * 3;
-  JDIMENSION inrows;
-
-  while (*out_row_group_ctr < out_row_groups_avail) {
-    if (*in_row_ctr < in_rows_avail) {
-      /* 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);
-      (*cinfo->cconvert->_color_convert) (cinfo, input_buf + *in_row_ctr,
-                                          prep->color_buf,
-                                          (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);
-          }
-        }
-      }
-      *in_row_ctr += numrows;
-      prep->next_buf_row += numrows;
-      prep->rows_to_go -= numrows;
-    } else {
-      /* Return for more data, unless we are at the bottom of the image. */
-      if (prep->rows_to_go != 0)
-        break;
-      /* When at bottom of image, pad to fill the conversion buffer. */
-      if (prep->next_buf_row < prep->next_buf_stop) {
-        for (ci = 0; ci < cinfo->num_components; ci++) {
-          expand_bottom_edge(prep->color_buf[ci], cinfo->image_width,
-                             prep->next_buf_row, prep->next_buf_stop);
-        }
-        prep->next_buf_row = prep->next_buf_stop;
-      }
-    }
-    /* 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,
-                                         output_buf, *out_row_group_ctr);
-      (*out_row_group_ctr)++;
-      /* Advance pointers with wraparound as necessary. */
-      prep->this_row_group += cinfo->max_v_samp_factor;
-      if (prep->this_row_group >= buf_height)
-        prep->this_row_group = 0;
-      if (prep->next_buf_row >= buf_height)
-        prep->next_buf_row = 0;
-      prep->next_buf_stop = prep->next_buf_row + cinfo->max_v_samp_factor;
-    }
-  }
-}
-
-
-/*
- * Create the wrapped-around downsampling input buffer needed for context mode.
- */
-
-LOCAL(void)
-create_context_buffer(j_compress_ptr cinfo)
-{
-  my_prep_ptr prep = (my_prep_ptr)cinfo->prep;
-  int rgroup_height = cinfo->max_v_samp_factor;
-  int ci, i;
-  jpeg_component_info *compptr;
-  _JSAMPARRAY true_buffer, fake_buffer;
-  int data_unit = cinfo->master->lossless ? 1 : DCTSIZE;
-
-  /* Grab enough space for fake row pointers for all the components;
-   * 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->num_components * 5 * rgroup_height) *
-                                sizeof(_JSAMPROW));
-
-  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-       ci++, compptr++) {
-    /* Allocate the actual buffer space (3 row groups) for this component.
-     * We make the buffer wide enough to allow the downsampler to edge-expand
-     * horizontally within the buffer, if it so chooses.
-     */
-    true_buffer = (_JSAMPARRAY)(*cinfo->mem->alloc_sarray)
-      ((j_common_ptr)cinfo, JPOOL_IMAGE,
-       (JDIMENSION)(((long)compptr->width_in_blocks * data_unit *
-                     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 */
-    memcpy(fake_buffer + rgroup_height, true_buffer,
-           3 * rgroup_height * sizeof(_JSAMPROW));
-    /* Fill in the above and below wraparound pointers */
-    for (i = 0; i < rgroup_height; i++) {
-      fake_buffer[i] = true_buffer[2 * rgroup_height + i];
-      fake_buffer[4 * rgroup_height + i] = true_buffer[i];
-    }
-    prep->color_buf[ci] = fake_buffer + rgroup_height;
-    fake_buffer += 5 * rgroup_height; /* point to space for next component */
-  }
-}
-
-#endif /* CONTEXT_ROWS_SUPPORTED */
-
-
-/*
- * Initialize preprocessing controller.
- */
-
-GLOBAL(void)
-_jinit_c_prep_controller(j_compress_ptr cinfo, boolean need_full_buffer)
-{
-  my_prep_ptr prep;
-  int ci;
-  jpeg_component_info *compptr;
-  int data_unit = cinfo->master->lossless ? 1 : DCTSIZE;
-
-  if (cinfo->data_precision != BITS_IN_JSAMPLE)
-    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-
-  if (need_full_buffer)         /* safety check */
-    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
-
-  prep = (my_prep_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                sizeof(my_prep_controller));
-  cinfo->prep = (struct jpeg_c_prep_controller *)prep;
-  prep->pub.start_pass = start_pass_prep;
-
-  /* Allocate the color conversion buffer.
-   * We make the buffer wide enough to allow the downsampler to edge-expand
-   * horizontally within the buffer, if it so chooses.
-   */
-  if (cinfo->downsample->need_context_rows) {
-    /* Set up to provide context rows */
-#ifdef CONTEXT_ROWS_SUPPORTED
-    prep->pub._pre_process_data = pre_process_context;
-    create_context_buffer(cinfo);
-#else
-    ERREXIT(cinfo, JERR_NOT_COMPILED);
-#endif
-  } else {
-    /* No context, just make it tall enough for one row group */
-    prep->pub._pre_process_data = pre_process_data;
-    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-         ci++, compptr++) {
-      prep->color_buf[ci] = (_JSAMPARRAY)(*cinfo->mem->alloc_sarray)
-        ((j_common_ptr)cinfo, JPOOL_IMAGE,
-         (JDIMENSION)(((long)compptr->width_in_blocks * data_unit *
-                       cinfo->max_h_samp_factor) / compptr->h_samp_factor),
-         (JDIMENSION)cinfo->max_v_samp_factor);
-    }
-  }
-}
-
-#endif /* BITS_IN_JSAMPLE != 16 || defined(C_LOSSLESS_SUPPORTED) */
@@ -1,543 +0,0 @@
-/*
- * jcsample.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1991-1996, Thomas G. Lane.
- * Lossless JPEG Modifications:
- * Copyright (C) 1999, Ken Murchison.
- * libjpeg-turbo Modifications:
- * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
- * Copyright (C) 2014, MIPS Technologies, Inc., California.
- * Copyright (C) 2015, 2019, 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains downsampling routines.
- *
- * Downsampling input data is counted in "row groups".  A row group
- * is defined to be max_v_samp_factor pixel rows of each component,
- * from which the downsampler produces v_samp_factor sample rows.
- * A single row group is processed in each call to the downsampler module.
- *
- * The downsampler is responsible for edge-expansion of its output data
- * to fill an integral number of DCT blocks horizontally.  The source buffer
- * may be modified if it is helpful for this purpose (the source buffer is
- * allocated wide enough to correspond to the desired output width).
- * The caller (the prep controller) is responsible for vertical padding.
- *
- * The downsampler may request "context rows" by setting need_context_rows
- * during startup.  In this case, the input arrays will contain at least
- * one row group's worth of pixels above and below the passed-in data;
- * the caller will create dummy rows at image top and bottom by replicating
- * the first or last real pixel row.
- *
- * An excellent reference for image resampling is
- *   Digital Image Warping, George Wolberg, 1990.
- *   Pub. by IEEE Computer Society Press, Los Alamitos, CA. ISBN 0-8186-8944-7.
- *
- * The downsampling algorithm used here is a simple average of the source
- * pixels covered by the output pixel.  The hi-falutin sampling literature
- * refers to this as a "box filter".  In general the characteristics of a box
- * filter are not very good, but for the specific cases we normally use (1:1
- * and 2:1 ratios) the box is equivalent to a "triangle filter" which is not
- * nearly so bad.  If you intend to use other sampling ratios, you'd be well
- * advised to improve this code.
- *
- * A simple input-smoothing capability is provided.  This is mainly intended
- * for cleaning up color-dithered GIF input files (if you find it inadequate,
- * we suggest using an external filtering program such as pnmconvol).  When
- * enabled, each input pixel P is replaced by a weighted sum of itself and its
- * eight neighbors.  P's weight is 1-8*SF and each neighbor's weight is SF,
- * where SF = (smoothing_factor / 1024).
- * Currently, smoothing is only supported for 2h2v sampling factors.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jsimd.h"
-#include "jsamplecomp.h"
-
-
-#if BITS_IN_JSAMPLE != 16 || defined(C_LOSSLESS_SUPPORTED)
-
-/* Pointer to routine to downsample a single component */
-typedef void (*downsample1_ptr) (j_compress_ptr cinfo,
-                                 jpeg_component_info *compptr,
-                                 _JSAMPARRAY input_data,
-                                 _JSAMPARRAY output_data);
-
-/* Private subobject */
-
-typedef struct {
-  struct jpeg_downsampler pub;  /* public fields */
-
-  /* Downsampling method pointers, one per component */
-  downsample1_ptr methods[MAX_COMPONENTS];
-} my_downsampler;
-
-typedef my_downsampler *my_downsample_ptr;
-
-
-/*
- * Initialize for a downsampling pass.
- */
-
-METHODDEF(void)
-start_pass_downsample(j_compress_ptr cinfo)
-{
-  /* no work for now */
-}
-
-
-/*
- * Expand a component horizontally from width input_cols to width output_cols,
- * by duplicating the rightmost samples.
- */
-
-LOCAL(void)
-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);
-
-  if (numcols > 0) {
-    for (row = 0; row < num_rows; row++) {
-      ptr = image_data[row] + input_cols;
-      pixval = ptr[-1];
-      for (count = numcols; count > 0; count--)
-        *ptr++ = pixval;
-    }
-  }
-}
-
-
-/*
- * Do downsampling for a whole row group (all components).
- *
- * In this version we simply downsample each component independently.
- */
-
-METHODDEF(void)
-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;
-  int ci;
-  jpeg_component_info *compptr;
-  _JSAMPARRAY in_ptr, out_ptr;
-
-  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-       ci++, compptr++) {
-    in_ptr = input_buf[ci] + in_row_index;
-    out_ptr = output_buf[ci] + (out_row_group_index * compptr->v_samp_factor);
-    (*downsample->methods[ci]) (cinfo, compptr, in_ptr, out_ptr);
-  }
-}
-
-
-/*
- * Downsample pixel values of a single component.
- * One row group is processed per call.
- * This version handles arbitrary integral sampling ratios, without smoothing.
- * Note that this version is not actually used for customary sampling ratios.
- */
-
-METHODDEF(void)
-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 */
-  int data_unit = cinfo->master->lossless ? 1 : DCTSIZE;
-  JDIMENSION output_cols = compptr->width_in_blocks * data_unit;
-  _JSAMPROW inptr, outptr;
-  JLONG outvalue;
-
-  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;
-
-  /* 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);
-
-  inrow = 0;
-  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
-    outptr = output_data[outrow];
-    for (outcol = 0, outcol_h = 0; outcol < output_cols;
-         outcol++, outcol_h += h_expand) {
-      outvalue = 0;
-      for (v = 0; v < v_expand; v++) {
-        inptr = input_data[inrow + v] + outcol_h;
-        for (h = 0; h < h_expand; h++) {
-          outvalue += (JLONG)(*inptr++);
-        }
-      }
-      *outptr++ = (_JSAMPLE)((outvalue + numpix2) / numpix);
-    }
-    inrow += v_expand;
-  }
-}
-
-
-/*
- * Downsample pixel values of a single component.
- * This version handles the special case of a full-size component,
- * without smoothing.
- */
-
-METHODDEF(void)
-fullsize_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
-                    _JSAMPARRAY input_data, _JSAMPARRAY output_data)
-{
-  int data_unit = cinfo->master->lossless ? 1 : DCTSIZE;
-
-  /* Copy the data */
-  _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 * data_unit);
-}
-
-
-/*
- * Downsample pixel values of a single component.
- * This version handles the common case of 2:1 horizontal and 1:1 vertical,
- * without smoothing.
- *
- * A note about the "bias" calculations: when rounding fractional values to
- * integer, we do not want to always round 0.5 up to the next integer.
- * If we did that, we'd introduce a noticeable bias towards larger values.
- * Instead, this code is arranged so that 0.5 will be rounded up or down at
- * alternate pixel locations (a simple ordered dither pattern).
- */
-
-METHODDEF(void)
-h2v1_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
-                _JSAMPARRAY input_data, _JSAMPARRAY output_data)
-{
-  int outrow;
-  JDIMENSION outcol;
-  int data_unit = cinfo->master->lossless ? 1 : DCTSIZE;
-  JDIMENSION output_cols = compptr->width_in_blocks * data_unit;
-  register _JSAMPROW inptr, outptr;
-  register int bias;
-
-  /* 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 * 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);
-      bias ^= 1;                /* 0=>1, 1=>0 */
-      inptr += 2;
-    }
-  }
-}
-
-
-/*
- * Downsample pixel values of a single component.
- * This version handles the standard case of 2:1 horizontal and 2:1 vertical,
- * without smoothing.
- */
-
-METHODDEF(void)
-h2v2_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
-                _JSAMPARRAY input_data, _JSAMPARRAY output_data)
-{
-  int inrow, outrow;
-  JDIMENSION outcol;
-  int data_unit = cinfo->master->lossless ? 1 : DCTSIZE;
-  JDIMENSION output_cols = compptr->width_in_blocks * data_unit;
-  register _JSAMPROW inptr0, inptr1, outptr;
-  register int bias;
-
-  /* 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 * 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];
-    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);
-      bias ^= 3;                /* 1=>2, 2=>1 */
-      inptr0 += 2;  inptr1 += 2;
-    }
-    inrow += 2;
-  }
-}
-
-
-#ifdef INPUT_SMOOTHING_SUPPORTED
-
-/*
- * Downsample pixel values of a single component.
- * This version handles the standard case of 2:1 horizontal and 2:1 vertical,
- * with smoothing.  One row of context is required.
- */
-
-METHODDEF(void)
-h2v2_smooth_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
-                       _JSAMPARRAY input_data, _JSAMPARRAY output_data)
-{
-  int inrow, outrow;
-  JDIMENSION colctr;
-  int data_unit = cinfo->master->lossless ? 1 : DCTSIZE;
-  JDIMENSION output_cols = compptr->width_in_blocks * data_unit;
-  register _JSAMPROW inptr0, inptr1, above_ptr, below_ptr, outptr;
-  JLONG membersum, neighsum, memberscale, neighscale;
-
-  /* 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 - 1, cinfo->max_v_samp_factor + 2,
-                    cinfo->image_width, output_cols * 2);
-
-  /* We don't bother to form the individual "smoothed" input pixel values;
-   * we can directly compute the output which is the average of the four
-   * smoothed values.  Each of the four member pixels contributes a fraction
-   * (1-8*SF) to its own smoothed image and a fraction SF to each of the three
-   * other smoothed pixels, therefore a total fraction (1-5*SF)/4 to the final
-   * output.  The four corner-adjacent neighbor pixels contribute a fraction
-   * SF to just one smoothed pixel, or SF/4 to the final output; while the
-   * eight edge-adjacent neighbors contribute SF to each of two smoothed
-   * pixels, or SF/2 overall.  In order to use integer arithmetic, these
-   * factors are scaled by 2^16 = 65536.
-   * Also recall that SF = smoothing_factor / 1024.
-   */
-
-  memberscale = 16384 - cinfo->smoothing_factor * 80; /* scaled (1-5*SF)/4 */
-  neighscale = cinfo->smoothing_factor * 16; /* scaled SF/4 */
-
-  inrow = 0;
-  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];
-
-    /* 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];
-    neighsum += neighsum;
-    neighsum += above_ptr[0] + above_ptr[2] + below_ptr[0] + below_ptr[2];
-    membersum = membersum * memberscale + neighsum * neighscale;
-    *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];
-      /* 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];
-      /* 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];
-      /* 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;
-    }
-
-    /* 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];
-    neighsum += neighsum;
-    neighsum += above_ptr[-1] + above_ptr[1] + below_ptr[-1] + below_ptr[1];
-    membersum = membersum * memberscale + neighsum * neighscale;
-    *outptr = (_JSAMPLE)((membersum + 32768) >> 16);
-
-    inrow += 2;
-  }
-}
-
-
-/*
- * Downsample pixel values of a single component.
- * This version handles the special case of a full-size component,
- * with smoothing.  One row of context is required.
- */
-
-METHODDEF(void)
-fullsize_smooth_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
-                           _JSAMPARRAY input_data, _JSAMPARRAY output_data)
-{
-  int outrow;
-  JDIMENSION colctr;
-  int data_unit = cinfo->master->lossless ? 1 : DCTSIZE;
-  JDIMENSION output_cols = compptr->width_in_blocks * data_unit;
-  register _JSAMPROW inptr, above_ptr, below_ptr, outptr;
-  JLONG membersum, neighsum, memberscale, neighscale;
-  int colsum, lastcolsum, nextcolsum;
-
-  /* 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 - 1, cinfo->max_v_samp_factor + 2,
-                    cinfo->image_width, output_cols);
-
-  /* Each of the eight neighbor pixels contributes a fraction SF to the
-   * smoothed pixel, while the main pixel contributes (1-8*SF).  In order
-   * to use integer arithmetic, these factors are multiplied by 2^16 = 65536.
-   * Also recall that SF = smoothing_factor / 1024.
-   */
-
-  memberscale = 65536L - cinfo->smoothing_factor * 512L; /* scaled 1-8*SF */
-  neighscale = cinfo->smoothing_factor * 64; /* scaled SF */
-
-  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];
-
-    /* Special case for first column */
-    colsum = (*above_ptr++) + (*below_ptr++) + inptr[0];
-    membersum = *inptr++;
-    nextcolsum = above_ptr[0] + below_ptr[0] + inptr[0];
-    neighsum = colsum + (colsum - membersum) + nextcolsum;
-    membersum = membersum * memberscale + neighsum * neighscale;
-    *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];
-      neighsum = lastcolsum + (colsum - membersum) + nextcolsum;
-      membersum = membersum * memberscale + neighsum * neighscale;
-      *outptr++ = (_JSAMPLE)((membersum + 32768) >> 16);
-      lastcolsum = colsum;  colsum = nextcolsum;
-    }
-
-    /* Special case for last column */
-    membersum = *inptr;
-    neighsum = lastcolsum + (colsum - membersum) + colsum;
-    membersum = membersum * memberscale + neighsum * neighscale;
-    *outptr = (_JSAMPLE)((membersum + 32768) >> 16);
-
-  }
-}
-
-#endif /* INPUT_SMOOTHING_SUPPORTED */
-
-
-/*
- * Module initialization routine for downsampling.
- * Note that we must select a routine for each component.
- */
-
-GLOBAL(void)
-_jinit_downsampler(j_compress_ptr cinfo)
-{
-  my_downsample_ptr downsample;
-  int ci;
-  jpeg_component_info *compptr;
-  boolean smoothok = TRUE;
-
-  if (cinfo->data_precision != BITS_IN_JSAMPLE)
-    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-
-  downsample = (my_downsample_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                sizeof(my_downsampler));
-  cinfo->downsample = (struct jpeg_downsampler *)downsample;
-  downsample->pub.start_pass = start_pass_downsample;
-  downsample->pub._downsample = sep_downsample;
-  downsample->pub.need_context_rows = FALSE;
-
-  if (cinfo->CCIR601_sampling)
-    ERREXIT(cinfo, JERR_CCIR601_NOTIMPL);
-
-  /* Verify we can handle the sampling factors, and set up method pointers */
-  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-       ci++, compptr++) {
-    if (compptr->h_samp_factor == cinfo->max_h_samp_factor &&
-        compptr->v_samp_factor == cinfo->max_v_samp_factor) {
-#ifdef INPUT_SMOOTHING_SUPPORTED
-      if (cinfo->smoothing_factor) {
-        downsample->methods[ci] = fullsize_smooth_downsample;
-        downsample->pub.need_context_rows = TRUE;
-      } else
-#endif
-        downsample->methods[ci] = fullsize_downsample;
-    } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor &&
-               compptr->v_samp_factor == cinfo->max_v_samp_factor) {
-      smoothok = FALSE;
-#ifdef WITH_SIMD
-      if (jsimd_can_h2v1_downsample())
-        downsample->methods[ci] = jsimd_h2v1_downsample;
-      else
-#endif
-        downsample->methods[ci] = h2v1_downsample;
-    } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor &&
-               compptr->v_samp_factor * 2 == cinfo->max_v_samp_factor) {
-#ifdef INPUT_SMOOTHING_SUPPORTED
-      if (cinfo->smoothing_factor) {
-#if defined(WITH_SIMD) && defined(__mips__)
-        if (jsimd_can_h2v2_smooth_downsample())
-          downsample->methods[ci] = jsimd_h2v2_smooth_downsample;
-        else
-#endif
-          downsample->methods[ci] = h2v2_smooth_downsample;
-        downsample->pub.need_context_rows = TRUE;
-      } else
-#endif
-      {
-#ifdef WITH_SIMD
-        if (jsimd_can_h2v2_downsample())
-          downsample->methods[ci] = jsimd_h2v2_downsample;
-        else
-#endif
-          downsample->methods[ci] = h2v2_downsample;
-      }
-    } else if ((cinfo->max_h_samp_factor % compptr->h_samp_factor) == 0 &&
-               (cinfo->max_v_samp_factor % compptr->v_samp_factor) == 0) {
-      smoothok = FALSE;
-      downsample->methods[ci] = int_downsample;
-    } else
-      ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL);
-  }
-
-#ifdef INPUT_SMOOTHING_SUPPORTED
-  if (cinfo->smoothing_factor && !smoothok)
-    TRACEMS(cinfo, 0, JTRC_SMOOTH_NOTIMPL);
-#endif
-}
-
-#endif /* BITS_IN_JSAMPLE != 16 || defined(C_LOSSLESS_SUPPORTED) */
@@ -1,415 +0,0 @@
-/*
- * jctrans.c
- *
- * 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, 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains library routines for transcoding compression,
- * that is, writing raw DCT coefficient arrays to an output JPEG file.
- * The routines in jcapimin.c will also be needed by a transcoder.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jpegapicomp.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);
-
-
-/*
- * Compression initialization for writing raw-coefficient data.
- * Before calling this, all parameters and a data destination must be set up.
- * Call jpeg_finish_compress() to actually write the data.
- *
- * The number of passed virtual arrays must match cinfo->num_components.
- * Note that the virtual arrays need not be filled or even realized at
- * the time write_coefficients is called; indeed, if the virtual arrays
- * were requested from this compression object's memory manager, they
- * typically will be realized during this routine and filled afterwards.
- */
-
-GLOBAL(void)
-jpeg_write_coefficients(j_compress_ptr cinfo, jvirt_barray_ptr *coef_arrays)
-{
-  if (cinfo->master->lossless)
-    ERREXIT(cinfo, JERR_NOTIMPL);
-
-  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->dest->init_destination) (cinfo);
-  /* Perform master selection of active modules */
-  transencode_master_selection(cinfo, coef_arrays);
-  /* Wait for jpeg_finish_compress() call */
-  cinfo->next_scanline = 0;     /* so jpeg_write_marker works */
-  cinfo->global_state = CSTATE_WRCOEFS;
-}
-
-
-/*
- * Initialize the compression object with default parameters,
- * then copy from the source object all parameters needed for lossless
- * transcoding.  Parameters that can be varied without loss (such as
- * scan script and Huffman optimization) are left in their default states.
- */
-
-GLOBAL(void)
-jpeg_copy_critical_parameters(j_decompress_ptr srcinfo, j_compress_ptr dstinfo)
-{
-  JQUANT_TBL **qtblptr;
-  jpeg_component_info *incomp, *outcomp;
-  JQUANT_TBL *c_quant, *slot_quant;
-  int tblno, ci, coefi;
-
-  if (srcinfo->master->lossless)
-    ERREXIT(dstinfo, JERR_NOTIMPL);
-
-  /* Safety check to ensure start_compress not called yet. */
-  if (dstinfo->global_state != CSTATE_START)
-    ERREXIT1(dstinfo, JERR_BAD_STATE, dstinfo->global_state);
-  /* Copy fundamental image dimensions */
-  dstinfo->image_width = srcinfo->image_width;
-  dstinfo->image_height = srcinfo->image_height;
-  dstinfo->input_components = srcinfo->num_components;
-  dstinfo->in_color_space = srcinfo->jpeg_color_space;
-#if JPEG_LIB_VERSION >= 70
-  dstinfo->jpeg_width = srcinfo->output_width;
-  dstinfo->jpeg_height = srcinfo->output_height;
-  dstinfo->min_DCT_h_scaled_size = srcinfo->min_DCT_h_scaled_size;
-  dstinfo->min_DCT_v_scaled_size = srcinfo->min_DCT_v_scaled_size;
-#endif
-  /* Initialize all parameters to default values */
-  jpeg_set_defaults(dstinfo);
-  /* jpeg_set_defaults may choose wrong colorspace, eg YCbCr if input is RGB.
-   * Fix it to get the right header markers for the image colorspace.
-   */
-  jpeg_set_colorspace(dstinfo, srcinfo->jpeg_color_space);
-  dstinfo->data_precision = srcinfo->data_precision;
-  dstinfo->CCIR601_sampling = srcinfo->CCIR601_sampling;
-  /* 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];
-      if (*qtblptr == NULL)
-        *qtblptr = jpeg_alloc_quant_table((j_common_ptr)dstinfo);
-      memcpy((*qtblptr)->quantval, srcinfo->quant_tbl_ptrs[tblno]->quantval,
-             sizeof((*qtblptr)->quantval));
-      (*qtblptr)->sent_table = FALSE;
-    }
-  }
-  /* Copy the source's per-component info.
-   * Note we assume jpeg_set_defaults has allocated the dest comp_info array.
-   */
-  dstinfo->num_components = srcinfo->num_components;
-  if (dstinfo->num_components < 1 || dstinfo->num_components > MAX_COMPONENTS)
-    ERREXIT2(dstinfo, JERR_COMPONENT_COUNT, dstinfo->num_components,
-             MAX_COMPONENTS);
-  for (ci = 0, incomp = srcinfo->comp_info, outcomp = dstinfo->comp_info;
-       ci < dstinfo->num_components; ci++, incomp++, outcomp++) {
-    outcomp->component_id = incomp->component_id;
-    outcomp->h_samp_factor = incomp->h_samp_factor;
-    outcomp->v_samp_factor = incomp->v_samp_factor;
-    outcomp->quant_tbl_no = incomp->quant_tbl_no;
-    /* Make sure saved quantization table for component matches the qtable
-     * slot.  If not, the input file re-used this qtable slot.
-     * IJG encoder currently cannot duplicate this.
-     */
-    tblno = outcomp->quant_tbl_no;
-    if (tblno < 0 || tblno >= NUM_QUANT_TBLS ||
-        srcinfo->quant_tbl_ptrs[tblno] == NULL)
-      ERREXIT1(dstinfo, JERR_NO_QUANT_TABLE, tblno);
-    slot_quant = srcinfo->quant_tbl_ptrs[tblno];
-    c_quant = incomp->quant_table;
-    if (c_quant != NULL) {
-      for (coefi = 0; coefi < DCTSIZE2; coefi++) {
-        if (c_quant->quantval[coefi] != slot_quant->quantval[coefi])
-          ERREXIT1(dstinfo, JERR_MISMATCHED_QUANT_TABLE, tblno);
-      }
-    }
-    /* Note: we do not copy the source's Huffman table assignments;
-     * instead we rely on jpeg_set_colorspace to have made a suitable choice.
-     */
-  }
-  /* Also copy JFIF version and resolution information, if available.
-   * Strictly speaking this isn't "critical" info, but it's nearly
-   * always appropriate to copy it if available.  In particular,
-   * if the application chooses to copy JFIF 1.02 extension markers from
-   * the source file, we need to copy the version to make sure we don't
-   * emit a file that has 1.02 extensions but a claimed version of 1.01.
-   * We will *not*, however, copy version info from mislabeled "2.01" files.
-   */
-  if (srcinfo->saw_JFIF_marker) {
-    if (srcinfo->JFIF_major_version == 1) {
-      dstinfo->JFIF_major_version = srcinfo->JFIF_major_version;
-      dstinfo->JFIF_minor_version = srcinfo->JFIF_minor_version;
-    }
-    dstinfo->density_unit = srcinfo->density_unit;
-    dstinfo->X_density = srcinfo->X_density;
-    dstinfo->Y_density = srcinfo->Y_density;
-  }
-}
-
-
-/*
- * Master selection of compression modules for transcoding.
- * This substitutes for jcinit.c's initialization of the full compressor.
- */
-
-LOCAL(void)
-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.
-   */
-  cinfo->input_components = 1;
-  /* Initialize master control (includes parameter checking/processing) */
-  jinit_c_master_control(cinfo, TRUE /* transcode only */);
-
-  /* Entropy encoding: either Huffman or arithmetic coding. */
-  if (cinfo->arith_code) {
-#ifdef C_ARITH_CODING_SUPPORTED
-    jinit_arith_encoder(cinfo);
-#else
-    ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
-#endif
-  } else {
-    if (cinfo->progressive_mode) {
-#ifdef C_PROGRESSIVE_SUPPORTED
-      jinit_phuff_encoder(cinfo);
-#else
-      ERREXIT(cinfo, JERR_NOT_COMPILED);
-#endif
-    } else
-      jinit_huff_encoder(cinfo);
-  }
-
-  /* We need a special coefficient buffer controller. */
-  transencode_coef_controller(cinfo, coef_arrays);
-
-  jinit_marker_writer(cinfo);
-
-  /* We can now tell the memory manager to allocate virtual arrays. */
-  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr)cinfo);
-
-  /* Write the datastream header (SOI, JFIF) immediately.
-   * Frame and scan headers are postponed till later.
-   * This lets application insert special markers after the SOI.
-   */
-  (*cinfo->marker->write_file_header) (cinfo);
-}
-
-
-/*
- * The rest of this file is a special implementation of the coefficient
- * buffer controller.  This is similar to jccoefct.c, but it handles only
- * output from presupplied virtual arrays.  Furthermore, we generate any
- * dummy padding blocks on-the-fly rather than expecting them to be present
- * in the arrays.
- */
-
-/* Private buffer controller object */
-
-typedef struct {
-  struct jpeg_c_coef_controller pub; /* public fields */
-
-  JDIMENSION iMCU_row_num;      /* iMCU row # within image */
-  JDIMENSION mcu_ctr;           /* counts MCUs processed in current row */
-  int MCU_vert_offset;          /* counts MCU rows within iMCU row */
-  int MCU_rows_per_iMCU_row;    /* number of such rows needed */
-
-  /* Virtual block array for each component. */
-  jvirt_barray_ptr *whole_image;
-
-  /* Workspace for constructing dummy blocks at right/bottom edges. */
-  JBLOCKROW dummy_buffer[C_MAX_BLOCKS_IN_MCU];
-} my_coef_controller;
-
-typedef my_coef_controller *my_coef_ptr;
-
-
-LOCAL(void)
-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;
-
-  /* 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.
-   * But at the bottom of the image, process only what's left.
-   */
-  if (cinfo->comps_in_scan > 1) {
-    coef->MCU_rows_per_iMCU_row = 1;
-  } else {
-    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;
-  }
-
-  coef->mcu_ctr = 0;
-  coef->MCU_vert_offset = 0;
-}
-
-
-/*
- * Initialize for a processing pass.
- */
-
-METHODDEF(void)
-start_pass_coef(j_compress_ptr cinfo, J_BUF_MODE pass_mode)
-{
-  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
-
-  if (pass_mode != JBUF_CRANK_DEST)
-    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
-
-  coef->iMCU_row_num = 0;
-  start_iMCU_row(cinfo);
-}
-
-
-/*
- * Process some data.
- * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
- * per call, ie, v_samp_factor block rows for each component in the scan.
- * The data is obtained from the virtual arrays and fed to the entropy coder.
- * Returns TRUE if the iMCU row is completed, FALSE if suspended.
- *
- * NB: input_buf is ignored; it is likely to be a NULL pointer.
- */
-
-METHODDEF(boolean)
-compress_output(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
-{
-  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;
-  int blkn, ci, xindex, yindex, yoffset, blockcnt;
-  JDIMENSION start_col;
-  JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
-  JBLOCKROW MCU_buffer[C_MAX_BLOCKS_IN_MCU];
-  JBLOCKROW buffer_ptr;
-  jpeg_component_info *compptr;
-
-  /* Align the virtual buffers for the components used in this scan. */
-  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],
-       coef->iMCU_row_num * compptr->v_samp_factor,
-       (JDIMENSION)compptr->v_samp_factor, FALSE);
-  }
-
-  /* Loop to process one whole iMCU row */
-  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
-       yoffset++) {
-    for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row;
-         MCU_col_num++) {
-      /* Construct list of pointers to DCT blocks belonging to this 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];
-        start_col = MCU_col_num * compptr->MCU_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) {
-            /* Fill in pointers to real blocks in this row */
-            buffer_ptr = buffer[ci][yindex + yoffset] + start_col;
-            for (xindex = 0; xindex < blockcnt; xindex++)
-              MCU_buffer[blkn++] = buffer_ptr++;
-          } else {
-            /* At bottom of image, need a whole row of dummy blocks */
-            xindex = 0;
-          }
-          /* Fill in any dummy blocks needed in this row.
-           * Dummy blocks are filled in the same way as in jccoefct.c:
-           * all zeroes in the AC entries, DC entries equal to previous
-           * block's DC value.  The init routine has already zeroed the
-           * AC entries, so we need only set the DC entries correctly.
-           */
-          for (; xindex < compptr->MCU_width; xindex++) {
-            MCU_buffer[blkn] = coef->dummy_buffer[blkn];
-            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)) {
-        /* Suspension forced; update state counters and exit */
-        coef->MCU_vert_offset = yoffset;
-        coef->mcu_ctr = MCU_col_num;
-        return FALSE;
-      }
-    }
-    /* Completed an MCU row, but perhaps not an iMCU row */
-    coef->mcu_ctr = 0;
-  }
-  /* Completed the iMCU row, advance counters for next one */
-  coef->iMCU_row_num++;
-  start_iMCU_row(cinfo);
-  return TRUE;
-}
-
-
-METHODDEF(boolean)
-compress_output_12(j_compress_ptr cinfo, J12SAMPIMAGE input_buf)
-{
-  return compress_output(cinfo, (JSAMPIMAGE)input_buf);
-}
-
-
-/*
- * Initialize coefficient buffer controller.
- *
- * Each passed coefficient array must be the right size for that
- * coefficient: width_in_blocks wide and height_in_blocks high,
- * with unitheight at least v_samp_factor.
- */
-
-LOCAL(void)
-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,
-                                sizeof(my_coef_controller));
-  cinfo->coef = (struct jpeg_c_coef_controller *)coef;
-  coef->pub.start_pass = start_pass_coef;
-  coef->pub.compress_data = compress_output;
-  coef->pub.compress_data_12 = compress_output_12;
-
-  /* Save pointer to virtual arrays */
-  coef->whole_image = coef_arrays;
-
-  /* Allocate and pre-zero space for dummy DCT blocks. */
-  buffer = (JBLOCKROW)
-    (*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));
-  for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
-    coef->dummy_buffer[i] = buffer + i;
-  }
-}
@@ -1,417 +0,0 @@
-/*
- * jdapimin.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1994-1998, Thomas G. Lane.
- * Lossless JPEG Modifications:
- * Copyright (C) 1999, Ken Murchison.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2016, 2022, 2024, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains application interface code for the decompression half
- * of the JPEG library.  These are the "minimum" API routines that may be
- * needed in either the normal full-decompression case or the
- * transcoding-only case.
- *
- * Most of the routines intended to be called directly by an application
- * are in this file or in jdapistd.c.  But also see jcomapi.c for routines
- * shared by compression and decompression, and jdtrans.c for the transcoding
- * case.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jdmaster.h"
-
-
-/*
- * Initialization of a JPEG decompression object.
- * The error manager must already be set up (in case memory manager fails).
- */
-
-GLOBAL(void)
-jpeg_CreateDecompress(j_decompress_ptr cinfo, int version, size_t structsize)
-{
-  int i;
-
-  /* Guard against version mismatches between library and caller. */
-  cinfo->mem = NULL;            /* so jpeg_destroy knows mem mgr not called */
-  if (version != JPEG_LIB_VERSION)
-    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);
-
-  /* For debugging purposes, we zero the whole master structure.
-   * But the application has already set the err pointer, and may have set
-   * client_data, so we have to save and restore those fields.
-   * Note: if application hasn't set client_data, tools like Purify may
-   * complain here.
-   */
-  {
-    struct jpeg_error_mgr *err = cinfo->err;
-    void *client_data = cinfo->client_data; /* ignore Purify complaint here */
-    memset(cinfo, 0, sizeof(struct jpeg_decompress_struct));
-    cinfo->err = err;
-    cinfo->client_data = client_data;
-  }
-  cinfo->is_decompressor = TRUE;
-
-  /* Initialize a memory manager instance for this object */
-  jinit_memory_mgr((j_common_ptr)cinfo);
-
-  /* Zero out pointers to permanent structures. */
-  cinfo->progress = NULL;
-  cinfo->src = NULL;
-
-  for (i = 0; i < NUM_QUANT_TBLS; i++)
-    cinfo->quant_tbl_ptrs[i] = NULL;
-
-  for (i = 0; i < NUM_HUFF_TBLS; i++) {
-    cinfo->dc_huff_tbl_ptrs[i] = NULL;
-    cinfo->ac_huff_tbl_ptrs[i] = NULL;
-  }
-
-  /* Initialize marker processor so application can override methods
-   * for COM, APPn markers before calling jpeg_read_header.
-   */
-  cinfo->marker_list = NULL;
-  jinit_marker_reader(cinfo);
-
-  /* And initialize the overall input controller. */
-  jinit_input_controller(cinfo);
-
-  cinfo->data_precision = BITS_IN_JSAMPLE;
-
-  /* OK, I'm ready */
-  cinfo->global_state = DSTATE_START;
-
-  /* The master struct is used to store extension parameters, so we allocate it
-   * here.
-   */
-  cinfo->master = (struct jpeg_decomp_master *)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
-                                sizeof(my_decomp_master));
-  memset(cinfo->master, 0, sizeof(my_decomp_master));
-}
-
-
-/*
- * Destruction of a JPEG decompression object
- */
-
-GLOBAL(void)
-jpeg_destroy_decompress(j_decompress_ptr cinfo)
-{
-  jpeg_destroy((j_common_ptr)cinfo); /* use common routine */
-}
-
-
-/*
- * Abort processing of a JPEG decompression operation,
- * but don't destroy the object itself.
- */
-
-GLOBAL(void)
-jpeg_abort_decompress(j_decompress_ptr cinfo)
-{
-  jpeg_abort((j_common_ptr)cinfo); /* use common routine */
-}
-
-
-/*
- * Set default decompression parameters.
- */
-
-LOCAL(void)
-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...) */
-  /* Note application may override our guesses. */
-  switch (cinfo->num_components) {
-  case 1:
-    cinfo->jpeg_color_space = JCS_GRAYSCALE;
-    cinfo->out_color_space = JCS_GRAYSCALE;
-    break;
-
-  case 3:
-    if (cinfo->saw_JFIF_marker) {
-      cinfo->jpeg_color_space = JCS_YCbCr; /* JFIF implies YCbCr */
-    } else if (cinfo->saw_Adobe_marker) {
-      switch (cinfo->Adobe_transform) {
-      case 0:
-        cinfo->jpeg_color_space = JCS_RGB;
-        break;
-      case 1:
-        cinfo->jpeg_color_space = JCS_YCbCr;
-        break;
-      default:
-        WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform);
-        cinfo->jpeg_color_space = JCS_YCbCr; /* assume it's YCbCr */
-        break;
-      }
-    } else {
-      /* Saw no special markers, try to guess from the component IDs */
-      int cid0 = cinfo->comp_info[0].component_id;
-      int cid1 = cinfo->comp_info[1].component_id;
-      int cid2 = cinfo->comp_info[2].component_id;
-
-      if (cid0 == 1 && cid1 == 2 && cid2 == 3) {
-        if (cinfo->master->lossless)
-          cinfo->jpeg_color_space = JCS_RGB; /* assume RGB w/out marker */
-        else
-          cinfo->jpeg_color_space = JCS_YCbCr; /* assume JFIF w/out marker */
-      } else if (cid0 == 82 && cid1 == 71 && cid2 == 66)
-        cinfo->jpeg_color_space = JCS_RGB; /* ASCII 'R', 'G', 'B' */
-      else {
-        TRACEMS3(cinfo, 1, JTRC_UNKNOWN_IDS, cid0, cid1, cid2);
-        if (cinfo->master->lossless)
-          cinfo->jpeg_color_space = JCS_RGB; /* assume it's RGB */
-        else
-          cinfo->jpeg_color_space = JCS_YCbCr; /* assume it's YCbCr */
-      }
-    }
-    /* Always guess RGB is proper output colorspace. */
-    cinfo->out_color_space = JCS_RGB;
-    break;
-
-  case 4:
-    if (cinfo->saw_Adobe_marker) {
-      switch (cinfo->Adobe_transform) {
-      case 0:
-        cinfo->jpeg_color_space = JCS_CMYK;
-        break;
-      case 2:
-        cinfo->jpeg_color_space = JCS_YCCK;
-        break;
-      default:
-        WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform);
-        cinfo->jpeg_color_space = JCS_YCCK; /* assume it's YCCK */
-        break;
-      }
-    } else {
-      /* No special markers, assume straight CMYK. */
-      cinfo->jpeg_color_space = JCS_CMYK;
-    }
-    cinfo->out_color_space = JCS_CMYK;
-    break;
-
-  default:
-    cinfo->jpeg_color_space = JCS_UNKNOWN;
-    cinfo->out_color_space = JCS_UNKNOWN;
-    break;
-  }
-
-  /* Set defaults for other decompression parameters. */
-  cinfo->scale_num = 1;         /* 1:1 scaling */
-  cinfo->scale_denom = 1;
-  cinfo->output_gamma = 1.0;
-  cinfo->buffered_image = FALSE;
-  cinfo->raw_data_out = FALSE;
-  cinfo->dct_method = JDCT_DEFAULT;
-  cinfo->do_fancy_upsampling = TRUE;
-  cinfo->do_block_smoothing = TRUE;
-  cinfo->quantize_colors = FALSE;
-  /* We set these in case application only sets quantize_colors. */
-  cinfo->dither_mode = JDITHER_FS;
-#ifdef QUANT_2PASS_SUPPORTED
-  cinfo->two_pass_quantize = TRUE;
-#else
-  cinfo->two_pass_quantize = FALSE;
-#endif
-  cinfo->desired_number_of_colors = 256;
-  cinfo->colormap = NULL;
-  /* Initialize for no mode change in buffered-image mode. */
-  cinfo->enable_1pass_quant = FALSE;
-  cinfo->enable_external_quant = FALSE;
-  cinfo->enable_2pass_quant = FALSE;
-}
-
-
-/*
- * Decompression startup: read start of JPEG datastream to see what's there.
- * Need only initialize JPEG object and supply a data source before calling.
- *
- * This routine will read as far as the first SOS marker (ie, actual start of
- * compressed data), and will save all tables and parameters in the JPEG
- * object.  It will also initialize the decompression parameters to default
- * values, and finally return JPEG_HEADER_OK.  On return, the application may
- * adjust the decompression parameters and then call jpeg_start_decompress.
- * (Or, if the application only wanted to determine the image parameters,
- * the data need not be decompressed.  In that case, call jpeg_abort or
- * jpeg_destroy to release any temporary space.)
- * If an abbreviated (tables only) datastream is presented, the routine will
- * return JPEG_HEADER_TABLES_ONLY upon reaching EOI.  The application may then
- * re-use the JPEG object to read the abbreviated image datastream(s).
- * It is unnecessary (but OK) to call jpeg_abort in this case.
- * The JPEG_SUSPENDED return code only occurs if the data source module
- * requests suspension of the decompressor.  In this case the application
- * should load more source data and then re-call jpeg_read_header to resume
- * processing.
- * If a non-suspending data source is used and require_image is TRUE, then the
- * return code need not be inspected since only JPEG_HEADER_OK is possible.
- *
- * This routine is now just a front end to jpeg_consume_input, with some
- * extra error checking.
- */
-
-GLOBAL(int)
-jpeg_read_header(j_decompress_ptr cinfo, boolean require_image)
-{
-  int retcode;
-
-  if (cinfo->global_state != DSTATE_START &&
-      cinfo->global_state != DSTATE_INHEADER)
-    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
-
-  retcode = jpeg_consume_input(cinfo);
-
-  switch (retcode) {
-  case JPEG_REACHED_SOS:
-    retcode = JPEG_HEADER_OK;
-    break;
-  case JPEG_REACHED_EOI:
-    if (require_image)          /* Complain if application wanted an image */
-      ERREXIT(cinfo, JERR_NO_IMAGE);
-    /* Reset to start state; it would be safer to require the application to
-     * 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 */
-    retcode = JPEG_HEADER_TABLES_ONLY;
-    break;
-  case JPEG_SUSPENDED:
-    /* no work */
-    break;
-  }
-
-  return retcode;
-}
-
-
-/*
- * Consume data in advance of what the decompressor requires.
- * This can be called at any time once the decompressor object has
- * been created and a data source has been set up.
- *
- * This routine is essentially a state machine that handles a couple
- * of critical state-transition actions, namely initial setup and
- * transition from header scanning to ready-for-start_decompress.
- * All the actual input is done via the input controller's consume_input
- * method.
- */
-
-GLOBAL(int)
-jpeg_consume_input(j_decompress_ptr cinfo)
-{
-  int retcode = JPEG_SUSPENDED;
-
-  /* NB: every possible DSTATE value should be listed in this switch */
-  switch (cinfo->global_state) {
-  case DSTATE_START:
-    /* Start-of-datastream actions: reset appropriate modules */
-    (*cinfo->inputctl->reset_input_controller) (cinfo);
-    /* Initialize application's data source module */
-    (*cinfo->src->init_source) (cinfo);
-    cinfo->global_state = DSTATE_INHEADER;
-    FALLTHROUGH                 /*FALLTHROUGH*/
-  case DSTATE_INHEADER:
-    retcode = (*cinfo->inputctl->consume_input) (cinfo);
-    if (retcode == JPEG_REACHED_SOS) { /* Found SOS, prepare to decompress */
-      /* Set up default parameters based on header data */
-      default_decompress_parms(cinfo);
-      /* Set global state: ready for start_decompress */
-      cinfo->global_state = DSTATE_READY;
-    }
-    break;
-  case DSTATE_READY:
-    /* Can't advance past first SOS until start_decompress is called */
-    retcode = JPEG_REACHED_SOS;
-    break;
-  case DSTATE_PRELOAD:
-  case DSTATE_PRESCAN:
-  case DSTATE_SCANNING:
-  case DSTATE_RAW_OK:
-  case DSTATE_BUFIMAGE:
-  case DSTATE_BUFPOST:
-  case DSTATE_STOPPING:
-    retcode = (*cinfo->inputctl->consume_input) (cinfo);
-    break;
-  default:
-    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
-  }
-  return retcode;
-}
-
-
-/*
- * Have we finished reading the input file?
- */
-
-GLOBAL(boolean)
-jpeg_input_complete(j_decompress_ptr cinfo)
-{
-  /* Check for valid jpeg object */
-  if (cinfo->global_state < DSTATE_START ||
-      cinfo->global_state > DSTATE_STOPPING)
-    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
-  return cinfo->inputctl->eoi_reached;
-}
-
-
-/*
- * Is there more than one scan?
- */
-
-GLOBAL(boolean)
-jpeg_has_multiple_scans(j_decompress_ptr cinfo)
-{
-  /* Only valid after jpeg_read_header completes */
-  if (cinfo->global_state < DSTATE_READY ||
-      cinfo->global_state > DSTATE_STOPPING)
-    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
-  return cinfo->inputctl->has_multiple_scans;
-}
-
-
-/*
- * Finish JPEG decompression.
- *
- * This will normally just verify the file trailer and release temp storage.
- *
- * Returns FALSE if suspended.  The return value need be inspected only if
- * a suspending data source is used.
- */
-
-GLOBAL(boolean)
-jpeg_finish_decompress(j_decompress_ptr cinfo)
-{
-  if ((cinfo->global_state == DSTATE_SCANNING ||
-       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);
-    (*cinfo->master->finish_output_pass) (cinfo);
-    cinfo->global_state = DSTATE_STOPPING;
-  } else if (cinfo->global_state == DSTATE_BUFIMAGE) {
-    /* Finishing after a buffered-image operation */
-    cinfo->global_state = DSTATE_STOPPING;
-  } else if (cinfo->global_state != DSTATE_STOPPING) {
-    /* STOPPING = repeat call after a suspension, anything else is error */
-    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
-  }
-  /* Read until EOI */
-  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);
-  return TRUE;
-}
@@ -1,752 +0,0 @@
-/*
- * jdapistd.c
- *
- * 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, 2022-2024, D. R. Commander.
- * Copyright (C) 2015, Google, Inc.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains application interface code for the decompression half
- * of the JPEG library.  These are the "standard" API routines that are
- * used in the normal full-decompression case.  They are not used by a
- * transcoding-only application.  Note that if an application links in
- * jpeg_start_decompress, it will end up linking in the entire decompressor.
- * We thus must separate this file from jdapimin.c to avoid linking the
- * whole decompression library into a transcoder.
- */
-
-#include "jinclude.h"
-#if BITS_IN_JSAMPLE != 16 || defined(D_LOSSLESS_SUPPORTED)
-#include "jdmainct.h"
-#include "jdcoefct.h"
-#else
-#define JPEG_INTERNALS
-#include "jpeglib.h"
-#endif
-#include "jdmaster.h"
-#include "jdmerge.h"
-#include "jdsample.h"
-#include "jmemsys.h"
-
-#if BITS_IN_JSAMPLE == 8
-
-/* Forward declarations */
-LOCAL(boolean) output_pass_setup(j_decompress_ptr cinfo);
-
-
-/*
- * Decompression initialization.
- * jpeg_read_header must be completed before calling this.
- *
- * If a multipass operating mode was selected, this will do all but the
- * last pass, and thus may take a great deal of time.
- *
- * Returns FALSE if suspended.  The return value need be inspected only if
- * a suspending data source is used.
- */
-
-GLOBAL(boolean)
-jpeg_start_decompress(j_decompress_ptr cinfo)
-{
-  if (cinfo->global_state == DSTATE_READY) {
-    /* First call: initialize master control, select active modules */
-    jinit_master_decompress(cinfo);
-    if (cinfo->buffered_image) {
-      /* No more work here; expecting jpeg_start_output next */
-      cinfo->global_state = DSTATE_BUFIMAGE;
-      return TRUE;
-    }
-    cinfo->global_state = DSTATE_PRELOAD;
-  }
-  if (cinfo->global_state == DSTATE_PRELOAD) {
-    /* If file has multiple scans, absorb them all into the coef buffer */
-    if (cinfo->inputctl->has_multiple_scans) {
-#ifdef D_MULTISCAN_FILES_SUPPORTED
-      for (;;) {
-        int retcode;
-        /* Call progress monitor hook if present */
-        if (cinfo->progress != NULL)
-          (*cinfo->progress->progress_monitor) ((j_common_ptr)cinfo);
-        /* Absorb some more input */
-        retcode = (*cinfo->inputctl->consume_input) (cinfo);
-        if (retcode == JPEG_SUSPENDED)
-          return FALSE;
-        if (retcode == JPEG_REACHED_EOI)
-          break;
-        /* Advance progress counter if appropriate */
-        if (cinfo->progress != NULL &&
-            (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;
-          }
-        }
-      }
-#else
-      ERREXIT(cinfo, JERR_NOT_COMPILED);
-#endif /* D_MULTISCAN_FILES_SUPPORTED */
-    }
-    cinfo->output_scan_number = cinfo->input_scan_number;
-  } else if (cinfo->global_state != DSTATE_PRESCAN)
-    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
-  /* Perform any dummy output passes, and set up for the final pass */
-  return output_pass_setup(cinfo);
-}
-
-
-/*
- * Set up for an output pass, and perform any dummy pass(es) needed.
- * Common subroutine for jpeg_start_decompress and jpeg_start_output.
- * Entry: global_state = DSTATE_PRESCAN only if previously suspended.
- * Exit: If done, returns TRUE and sets global_state for proper output mode.
- *       If suspended, returns FALSE and sets global_state = DSTATE_PRESCAN.
- */
-
-LOCAL(boolean)
-output_pass_setup(j_decompress_ptr cinfo)
-{
-  if (cinfo->global_state != DSTATE_PRESCAN) {
-    /* First call: do pass setup */
-    (*cinfo->master->prepare_for_output_pass) (cinfo);
-    cinfo->output_scanline = 0;
-    cinfo->global_state = DSTATE_PRESCAN;
-  }
-  /* Loop over any required dummy passes */
-  while (cinfo->master->is_dummy_pass) {
-#ifdef QUANT_2PASS_SUPPORTED
-    /* Crank through the dummy pass */
-    while (cinfo->output_scanline < cinfo->output_height) {
-      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);
-      }
-      /* Process some data */
-      last_scanline = cinfo->output_scanline;
-#ifdef D_LOSSLESS_SUPPORTED
-      if (cinfo->data_precision == 16)
-        (*cinfo->main->process_data_16) (cinfo, (J16SAMPARRAY)NULL,
-                                         &cinfo->output_scanline,
-                                         (JDIMENSION)0);
-      else
-#endif
-      if (cinfo->data_precision == 12)
-        (*cinfo->main->process_data_12) (cinfo, (J12SAMPARRAY)NULL,
-                                         &cinfo->output_scanline,
-                                         (JDIMENSION)0);
-      else
-        (*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 */
-    }
-    /* Finish up dummy pass, and set up for another one */
-    (*cinfo->master->finish_output_pass) (cinfo);
-    (*cinfo->master->prepare_for_output_pass) (cinfo);
-    cinfo->output_scanline = 0;
-#else
-    ERREXIT(cinfo, JERR_NOT_COMPILED);
-#endif /* QUANT_2PASS_SUPPORTED */
-  }
-  /* Ready for application to drive output pass through
-   * _jpeg_read_scanlines or _jpeg_read_raw_data.
-   */
-  cinfo->global_state = cinfo->raw_data_out ? DSTATE_RAW_OK : DSTATE_SCANNING;
-  return TRUE;
-}
-
-#endif /* BITS_IN_JSAMPLE == 8 */
-
-
-#if BITS_IN_JSAMPLE != 16
-
-/*
- * Enable partial scanline decompression
- *
- * Must be called after jpeg_start_decompress() and before any calls to
- * _jpeg_read_scanlines() or _jpeg_skip_scanlines().
- *
- * Refer to libjpeg.txt for more information.
- */
-
-GLOBAL(void)
-_jpeg_crop_scanline(j_decompress_ptr cinfo, JDIMENSION *xoffset,
-                    JDIMENSION *width)
-{
-  int ci, align, orig_downsampled_width;
-  JDIMENSION input_xoffset;
-  boolean reinit_upsampler = FALSE;
-  jpeg_component_info *compptr;
-#ifdef UPSAMPLE_MERGING_SUPPORTED
-  my_master_ptr master = (my_master_ptr)cinfo->master;
-#endif
-
-  if (cinfo->data_precision != BITS_IN_JSAMPLE)
-    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-
-  if (cinfo->master->lossless)
-    ERREXIT(cinfo, JERR_NOTIMPL);
-
-  if ((cinfo->global_state != DSTATE_SCANNING &&
-       cinfo->global_state != DSTATE_BUFIMAGE) || cinfo->output_scanline != 0)
-    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
-
-  if (!xoffset || !width)
-    ERREXIT(cinfo, JERR_BAD_CROP_SPEC);
-
-  /* xoffset and width must fall within the output image dimensions. */
-  if (*width == 0 ||
-      (unsigned long long)(*xoffset) + *width > cinfo->output_width)
-    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
-
-  /* No need to do anything if the caller wants the entire width. */
-  if (*width == cinfo->output_width)
-    return;
-
-  /* Ensuring the proper alignment of xoffset is tricky.  At minimum, it
-   * must align with an MCU boundary, because:
-   *
-   *   (1) The IDCT is performed in blocks, and it is not feasible to modify
-   *       the algorithm so that it can transform partial blocks.
-   *   (2) Because of the SIMD extensions, any input buffer passed to the
-   *       upsampling and color conversion routines must be aligned to the
-   *       SIMD word size (for instance, 128-bit in the case of SSE2.)  The
-   *       easiest way to accomplish this without copying data is to ensure
-   *       that upsampling and color conversion begin at the start of the
-   *       first MCU column that will be inverse transformed.
-   *
-   * In practice, we actually impose a stricter alignment requirement.  We
-   * require that xoffset be a multiple of the maximum MCU column width of all
-   * of the components (the "iMCU column width.")  This is to simplify the
-   * single-pass decompression case, allowing us to use the same MCU column
-   * width for all of the components.
-   */
-  if (cinfo->comps_in_scan == 1 && cinfo->num_components == 1)
-    align = cinfo->_min_DCT_scaled_size;
-  else
-    align = cinfo->_min_DCT_scaled_size * cinfo->max_h_samp_factor;
-
-  /* Adjust xoffset to the nearest iMCU boundary <= the requested value */
-  input_xoffset = *xoffset;
-  *xoffset = (input_xoffset / align) * align;
-
-  /* Adjust the width so that the right edge of the output image is as
-   * requested (only the left edge is altered.)  It is important that calling
-   * programs check this value after this function returns, so that they can
-   * allocate an output buffer with the appropriate size.
-   */
-  *width = *width + input_xoffset - *xoffset;
-  cinfo->output_width = *width;
-#ifdef UPSAMPLE_MERGING_SUPPORTED
-  if (master->using_merged_upsample && cinfo->max_v_samp_factor == 2) {
-    my_merged_upsample_ptr upsample = (my_merged_upsample_ptr)cinfo->upsample;
-    upsample->out_row_width =
-      cinfo->output_width * cinfo->out_color_components;
-  }
-#endif
-
-  /* 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->last_iMCU_col =
-    (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++) {
-    int hsf = (cinfo->comps_in_scan == 1 && cinfo->num_components == 1) ?
-              1 : compptr->h_samp_factor;
-
-    /* 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 *
-                                (long)(compptr->h_samp_factor *
-                                       compptr->_DCT_scaled_size),
-                                (long)(cinfo->max_h_samp_factor *
-                                       cinfo->_min_DCT_scaled_size));
-    if (compptr->downsampled_width < 2 && orig_downsampled_width >= 2)
-      reinit_upsampler = TRUE;
-
-    /* Set the first and last iMCU columns that we must decompress.  These
-     * values will be used in multi-scan decompressions.
-     */
-    cinfo->master->first_MCU_col[ci] =
-      (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;
-  }
-
-  if (reinit_upsampler) {
-    cinfo->master->jinit_upsampler_no_alloc = TRUE;
-    _jinit_upsampler(cinfo);
-    cinfo->master->jinit_upsampler_no_alloc = FALSE;
-  }
-}
-
-#endif /* BITS_IN_JSAMPLE != 16 */
-
-
-/*
- * Read some scanlines of data from the JPEG decompressor.
- *
- * The return value will be the number of lines actually read.
- * This may be less than the number requested in several cases,
- * including bottom of image, data source suspension, and operating
- * modes that emit multiple scanlines at a time.
- *
- * Note: we warn about excess calls to _jpeg_read_scanlines() since
- * this likely signals an application programmer error.  However,
- * an oversize buffer (max_lines > scanlines remaining) is not an error.
- */
-
-GLOBAL(JDIMENSION)
-_jpeg_read_scanlines(j_decompress_ptr cinfo, _JSAMPARRAY scanlines,
-                     JDIMENSION max_lines)
-{
-#if BITS_IN_JSAMPLE != 16 || defined(D_LOSSLESS_SUPPORTED)
-  JDIMENSION row_ctr;
-
-  if (cinfo->data_precision != BITS_IN_JSAMPLE)
-    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-
-  if (cinfo->global_state != DSTATE_SCANNING)
-    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
-  if (cinfo->output_scanline >= cinfo->output_height) {
-    WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
-    return 0;
-  }
-
-  /* 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);
-  }
-
-  /* Process some data */
-  row_ctr = 0;
-  (*cinfo->main->_process_data) (cinfo, scanlines, &row_ctr, max_lines);
-  cinfo->output_scanline += row_ctr;
-  return row_ctr;
-#else
-  ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-  return 0;
-#endif
-}
-
-
-#if BITS_IN_JSAMPLE != 16
-
-/* 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)
-{
-}
-
-
-/* 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)
-{
-}
-
-
-/*
- * In some cases, it is best to call _jpeg_read_scanlines() and discard the
- * output, rather than skipping the scanlines, because this allows us to
- * maintain the internal state of the context-based upsampler.  In these cases,
- * we set up and tear down a dummy color converter in order to avoid valgrind
- * errors and to achieve the best possible performance.
- */
-
-LOCAL(void)
-read_and_discard_scanlines(j_decompress_ptr cinfo, JDIMENSION num_lines)
-{
-  JDIMENSION n;
-#ifdef UPSAMPLE_MERGING_SUPPORTED
-  my_master_ptr master = (my_master_ptr)cinfo->master;
-#endif
-  _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;
-  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;
-  }
-
-  if (cinfo->cquantize && cinfo->cquantize->_color_quantize) {
-    color_quantize = cinfo->cquantize->_color_quantize;
-    cinfo->cquantize->_color_quantize = noop_quantize;
-  }
-
-#ifdef UPSAMPLE_MERGING_SUPPORTED
-  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;
-  }
-#endif
-
-  for (n = 0; n < num_lines; n++)
-    _jpeg_read_scanlines(cinfo, scanlines, 1);
-
-  if (color_convert)
-    cinfo->cconvert->_color_convert = color_convert;
-
-  if (color_quantize)
-    cinfo->cquantize->_color_quantize = color_quantize;
-}
-
-
-/*
- * Called by _jpeg_skip_scanlines().  This partially skips a decompress block
- * by incrementing the rowgroup counter.
- */
-
-LOCAL(void)
-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;
-  }
-
-  /* Increment the counter to the next row group after the skipped rows. */
-  main_ptr->rowgroup_ctr += rows / cinfo->max_v_samp_factor;
-
-  /* Partially skipping a row group would involve modifying the internal state
-   * of the upsampler, so read the remaining rows into a dummy buffer instead.
-   */
-  rows_left = rows % cinfo->max_v_samp_factor;
-  cinfo->output_scanline += rows - rows_left;
-
-  read_and_discard_scanlines(cinfo, rows_left);
-}
-
-/*
- * Skips some scanlines of data from the JPEG decompressor.
- *
- * The return value will be the number of lines actually skipped.  If skipping
- * num_lines would move beyond the end of the image, then the actual number of
- * lines remaining in the image is returned.  Otherwise, the return value will
- * be equal to num_lines.
- *
- * Refer to libjpeg.txt for more information.
- */
-
-GLOBAL(JDIMENSION)
-_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;
-  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;
-
-  if (cinfo->data_precision != BITS_IN_JSAMPLE)
-    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-
-  if (cinfo->master->lossless)
-    ERREXIT(cinfo, JERR_NOTIMPL);
-
-  /* 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 ((unsigned long long)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;
-  }
-
-  if (num_lines == 0)
-    return 0;
-
-  lines_per_iMCU_row = cinfo->_min_DCT_scaled_size * cinfo->max_v_samp_factor;
-  lines_left_in_iMCU_row =
-    (lines_per_iMCU_row - (cinfo->output_scanline % lines_per_iMCU_row)) %
-    lines_per_iMCU_row;
-  lines_after_iMCU_row = num_lines - lines_left_in_iMCU_row;
-
-  /* Skip the lines remaining in the current iMCU row.  When upsampling
-   * requires context rows, we need the previous and next rows in order to read
-   * the current row.  This adds some complexity.
-   */
-  if (cinfo->upsample->need_context_rows) {
-    /* If the skipped lines would not move us past the current iMCU row, we
-     * read the lines and ignore them.  There might be a faster way of doing
-     * this, but we are facing increasing complexity for diminishing returns.
-     * The increasing complexity would be a by-product of meddling with the
-     * state machine used to skip context rows.  Near the end of an iMCU row,
-     * the next iMCU row may have already been entropy-decoded.  In this unique
-     * case, we will read the next iMCU row if we cannot skip past it as well.
-     */
-    if ((num_lines < lines_left_in_iMCU_row + 1) ||
-        (lines_left_in_iMCU_row <= 1 && main_ptr->buffer_full &&
-         lines_after_iMCU_row < lines_per_iMCU_row + 1)) {
-      read_and_discard_scanlines(cinfo, num_lines);
-      return num_lines;
-    }
-
-    /* If the next iMCU row has already been entropy-decoded, make sure that
-     * we do not skip too far.
-     */
-    if (lines_left_in_iMCU_row <= 1 && main_ptr->buffer_full) {
-      cinfo->output_scanline += lines_left_in_iMCU_row + lines_per_iMCU_row;
-      lines_after_iMCU_row -= lines_per_iMCU_row;
-    } else {
-      cinfo->output_scanline += lines_left_in_iMCU_row;
-    }
-
-    /* If we have just completed the first block, adjust the buffer pointers */
-    if (main_ptr->iMCU_row_ctr == 0 ||
-        (main_ptr->iMCU_row_ctr == 1 && lines_left_in_iMCU_row > 2))
-      set_wraparound_pointers(cinfo);
-    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;
-    }
-  }
-
-  /* Skipping is much simpler when context rows are not required. */
-  else {
-    if (num_lines < lines_left_in_iMCU_row) {
-      increment_simple_rowgroup_ctr(cinfo, num_lines);
-      return num_lines;
-    } else {
-      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;
-      }
-    }
-  }
-
-  /* Calculate how many full iMCU rows we can skip. */
-  if (cinfo->upsample->need_context_rows)
-    lines_to_skip = ((lines_after_iMCU_row - 1) / lines_per_iMCU_row) *
-                    lines_per_iMCU_row;
-  else
-    lines_to_skip = (lines_after_iMCU_row / lines_per_iMCU_row) *
-                    lines_per_iMCU_row;
-  /* Calculate the number of lines that remain to be skipped after skipping all
-   * of the full iMCU rows that we can.  We will not read these lines unless we
-   * have to.
-   */
-  lines_to_read = lines_after_iMCU_row - lines_to_skip;
-
-  /* For images requiring multiple scans (progressive, non-interleaved, etc.),
-   * all of the entropy decoding occurs in jpeg_start_decompress(), assuming
-   * that the input data source is non-suspending.  This makes skipping easy.
-   */
-  if (cinfo->inputctl->has_multiple_scans || cinfo->buffered_image) {
-    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;
-      /* It is complex to properly move to the middle of a context block, so
-       * read the remaining lines instead of skipping them.
-       */
-      read_and_discard_scanlines(cinfo, lines_to_read);
-    } else {
-      cinfo->output_scanline += lines_to_skip;
-      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;
-    return num_lines;
-  }
-
-  /* Skip the iMCU rows that we can safely skip. */
-  for (i = 0; i < lines_to_skip; i += lines_per_iMCU_row) {
-    for (y = 0; y < coef->MCU_rows_per_iMCU_row; y++) {
-      for (x = 0; x < cinfo->MCUs_per_row; x++) {
-        /* Calling decode_mcu() with a NULL pointer causes it to discard the
-         * 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);
-      }
-    }
-    cinfo->input_iMCU_row++;
-    cinfo->output_iMCU_row++;
-    if (cinfo->input_iMCU_row < cinfo->total_iMCU_rows)
-      start_iMCU_row(cinfo);
-    else
-      (*cinfo->inputctl->finish_input_pass) (cinfo);
-  }
-  cinfo->output_scanline += lines_to_skip;
-
-  if (cinfo->upsample->need_context_rows) {
-    /* Context-based upsampling keeps track of iMCU rows. */
-    main_ptr->iMCU_row_ctr += lines_to_skip / 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.
-     */
-    read_and_discard_scanlines(cinfo, lines_to_read);
-  } else {
-    increment_simple_rowgroup_ctr(cinfo, lines_to_read);
-  }
-
-  /* Since skipping lines involves skipping the upsampling step, the value of
-   * "rows_to_go" will become invalid unless we set it here.  NOTE: This is a
-   * 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;
-
-  /* Always skip the requested number of lines. */
-  return num_lines;
-}
-
-/*
- * Alternate entry point to read raw data.
- * Processes exactly one iMCU row per call, unless suspended.
- */
-
-GLOBAL(JDIMENSION)
-_jpeg_read_raw_data(j_decompress_ptr cinfo, _JSAMPIMAGE data,
-                    JDIMENSION max_lines)
-{
-  JDIMENSION lines_per_iMCU_row;
-
-  if (cinfo->data_precision != BITS_IN_JSAMPLE)
-    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-
-  if (cinfo->master->lossless)
-    ERREXIT(cinfo, JERR_NOTIMPL);
-
-  if (cinfo->global_state != DSTATE_RAW_OK)
-    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
-  if (cinfo->output_scanline >= cinfo->output_height) {
-    WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
-    return 0;
-  }
-
-  /* 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);
-  }
-
-  /* Verify that at least one iMCU row can be returned. */
-  lines_per_iMCU_row = cinfo->max_v_samp_factor * cinfo->_min_DCT_scaled_size;
-  if (max_lines < lines_per_iMCU_row)
-    ERREXIT(cinfo, JERR_BUFFER_SIZE);
-
-  /* Decompress directly into user's buffer. */
-  if (!(*cinfo->coef->_decompress_data) (cinfo, data))
-    return 0;                   /* suspension forced, can do nothing more */
-
-  /* OK, we processed one iMCU row. */
-  cinfo->output_scanline += lines_per_iMCU_row;
-  return lines_per_iMCU_row;
-}
-
-#endif /* BITS_IN_JSAMPLE != 16 */
-
-
-#if BITS_IN_JSAMPLE == 8
-
-/* Additional entry points for buffered-image mode. */
-
-#ifdef D_MULTISCAN_FILES_SUPPORTED
-
-/*
- * Initialize for an output pass in buffered-image mode.
- */
-
-GLOBAL(boolean)
-jpeg_start_output(j_decompress_ptr cinfo, int scan_number)
-{
-  if (cinfo->global_state != DSTATE_BUFIMAGE &&
-      cinfo->global_state != DSTATE_PRESCAN)
-    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
-  /* Limit scan number to valid range */
-  if (scan_number <= 0)
-    scan_number = 1;
-  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 */
-  return output_pass_setup(cinfo);
-}
-
-
-/*
- * Finish up after an output pass in buffered-image mode.
- *
- * Returns FALSE if suspended.  The return value need be inspected only if
- * a suspending data source is used.
- */
-
-GLOBAL(boolean)
-jpeg_finish_output(j_decompress_ptr cinfo)
-{
-  if ((cinfo->global_state == DSTATE_SCANNING ||
-       cinfo->global_state == DSTATE_RAW_OK) && cinfo->buffered_image) {
-    /* Terminate this pass. */
-    /* We do not require the whole pass to have been completed. */
-    (*cinfo->master->finish_output_pass) (cinfo);
-    cinfo->global_state = DSTATE_BUFPOST;
-  } else if (cinfo->global_state != DSTATE_BUFPOST) {
-    /* BUFPOST = repeat call after a suspension, anything else is error */
-    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
-  }
-  /* Read markers looking for SOS or EOI */
-  while (cinfo->input_scan_number <= cinfo->output_scan_number &&
-         !cinfo->inputctl->eoi_reached) {
-    if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)
-      return FALSE;             /* Suspend, come back later */
-  }
-  cinfo->global_state = DSTATE_BUFIMAGE;
-  return TRUE;
-}
-
-#endif /* D_MULTISCAN_FILES_SUPPORTED */
-
-#endif /* BITS_IN_JSAMPLE == 8 */
@@ -1,782 +0,0 @@
-/*
- * jdarith.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Developed 1997-2015 by Guido Vollbeding.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2015-2020, 2022, 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).
- *
- * 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
-#include "jinclude.h"
-#include "jpeglib.h"
-
-
-#define NEG_1  ((unsigned int)-1)
-
-
-/* Expanded entropy decoder object for arithmetic decoding. */
-
-typedef struct {
-  struct jpeg_entropy_decoder pub; /* public fields */
-
-  JLONG c;       /* C register, base of coding interval + input bit buffer */
-  JLONG a;               /* A register, normalized size of coding interval */
-  int ct;     /* bit shift counter, # of bits left in bit buffer part of C */
-                                                         /* init: ct = -16 */
-                                                         /* run: ct = 0..7 */
-                                                         /* error: ct = -1 */
-  int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
-  int dc_context[MAX_COMPS_IN_SCAN]; /* context index for DC conditioning */
-
-  unsigned int restarts_to_go;  /* MCUs left in this restart interval */
-
-  /* Pointers to statistics areas (these workspaces have image lifespan) */
-  unsigned char *dc_stats[NUM_ARITH_TBLS];
-  unsigned char *ac_stats[NUM_ARITH_TBLS];
-
-  /* Statistics bin for coding with fixed probability 0.5 */
-  unsigned char fixed_bin[4];
-} arith_entropy_decoder;
-
-typedef arith_entropy_decoder *arith_entropy_ptr;
-
-/* The following two definitions specify the allocation chunk size
- * for the statistics area.
- * According to sections F.1.4.4.1.3 and F.1.4.4.2, we need at least
- * 49 statistics bins for DC, and 245 statistics bins for AC coding.
- *
- * We use a compact representation with 1 byte per statistics bin,
- * thus the numbers directly represent byte sizes.
- * This 1 byte per statistics bin contains the meaning of the MPS
- * (more probable symbol) in the highest bit (mask 0x80), and the
- * index into the probability estimation state machine table
- * in the lower bits (mask 0x7F).
- */
-
-#define DC_STAT_BINS  64
-#define AC_STAT_BINS  256
-
-
-LOCAL(int)
-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))
-      ERREXIT(cinfo, JERR_CANT_SUSPEND);
-  src->bytes_in_buffer--;
-  return *src->next_input_byte++;
-}
-
-
-/*
- * The core arithmetic decoding routine (common in JPEG and JBIG).
- * This needs to go as fast as possible.
- * Machine-dependent optimization facilities
- * are not utilized in this portable implementation.
- * However, this code should be fairly efficient and
- * may be a good base for further optimizations anyway.
- *
- * Return value is 0 or 1 (binary decision).
- *
- * Note: I've changed the handling of the code base & bit
- * buffer register C compared to other implementations
- * based on the standards layout & procedures.
- * While it also contains both the actual base of the
- * coding interval (16 bits) and the next-bits buffer,
- * the cut-point between these two parts is floating
- * (instead of fixed) with the bit shift counter CT.
- * Thus, we also need only one (variable instead of
- * fixed size) shift for the LPS/MPS decision, and
- * we can do away with any renormalization update
- * of C (except for new data insertion, of course).
- *
- * I've also introduced a new scheme for accessing
- * the probability estimation state machine table,
- * derived from Markus Kuhn's JBIG implementation.
- */
-
-LOCAL(int)
-arith_decode(j_decompress_ptr cinfo, unsigned char *st)
-{
-  register arith_entropy_ptr e = (arith_entropy_ptr)cinfo->entropy;
-  register unsigned char nl, nm;
-  register JLONG qe, temp;
-  register int sv, data;
-
-  /* Renormalization & data input per section D.2.6 */
-  while (e->a < 0x8000L) {
-    if (--e->ct < 0) {
-      /* Need to fetch next data byte */
-      if (cinfo->unread_marker)
-        data = 0;               /* stuff zero data */
-      else {
-        data = get_byte(cinfo); /* read next input byte */
-        if (data == 0xFF) {     /* zero stuff or marker code */
-          do data = get_byte(cinfo);
-          while (data == 0xFF); /* swallow extra 0xFF bytes */
-          if (data == 0)
-            data = 0xFF;        /* discard stuffed zero byte */
-          else {
-            /* Note: Different from the Huffman decoder, hitting
-             * a marker while processing the compressed data
-             * segment is legal in arithmetic coding.
-             * The convention is to supply zero data
-             * then until decoding is complete.
-             */
-            cinfo->unread_marker = data;
-            data = 0;
-          }
-        }
-      }
-      e->c = (e->c << 8) | data; /* insert data into C register */
-      if ((e->ct += 8) < 0)      /* update bit shift counter */
-        /* Need more initial bytes */
-        if (++e->ct == 0)
-          /* Got 2 initial bytes -> re-init A and exit loop */
-          e->a = 0x8000L; /* => e->a = 0x10000L after loop exit */
-    }
-    e->a <<= 1;
-  }
-
-  /* Fetch values from our compact representation of Table D.2:
-   * Qe values and probability estimation state machine
-   */
-  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 */
-
-  /* Decode & estimation procedures per sections D.2.4 & D.2.5 */
-  temp = e->a - qe;
-  e->a = temp;
-  temp <<= e->ct;
-  if (e->c >= temp) {
-    e->c -= temp;
-    /* Conditional LPS (less probable symbol) exchange */
-    if (e->a < qe) {
-      e->a = qe;
-      *st = (sv & 0x80) ^ nm;   /* Estimate_after_MPS */
-    } else {
-      e->a = qe;
-      *st = (sv & 0x80) ^ nl;   /* Estimate_after_LPS */
-      sv ^= 0x80;               /* Exchange LPS/MPS */
-    }
-  } else if (e->a < 0x8000L) {
-    /* Conditional MPS (more probable symbol) exchange */
-    if (e->a < qe) {
-      *st = (sv & 0x80) ^ nl;   /* Estimate_after_LPS */
-      sv ^= 0x80;               /* Exchange LPS/MPS */
-    } else {
-      *st = (sv & 0x80) ^ nm;   /* Estimate_after_MPS */
-    }
-  }
-
-  return sv >> 7;
-}
-
-
-/*
- * Check for a restart marker & resynchronize decoder.
- */
-
-LOCAL(void)
-process_restart(j_decompress_ptr cinfo)
-{
-  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))
-    ERREXIT(cinfo, JERR_CANT_SUSPEND);
-
-  /* Re-initialize statistics areas */
-  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
-    compptr = cinfo->cur_comp_info[ci];
-    if (!cinfo->progressive_mode || (cinfo->Ss == 0 && cinfo->Ah == 0)) {
-      memset(entropy->dc_stats[compptr->dc_tbl_no], 0, DC_STAT_BINS);
-      /* Reset DC predictions to 0 */
-      entropy->last_dc_val[ci] = 0;
-      entropy->dc_context[ci] = 0;
-    }
-    if (!cinfo->progressive_mode || cinfo->Ss) {
-      memset(entropy->ac_stats[compptr->ac_tbl_no], 0, AC_STAT_BINS);
-    }
-  }
-
-  /* Reset arithmetic decoding variables */
-  entropy->c = 0;
-  entropy->a = 0;
-  entropy->ct = -16;    /* force reading 2 initial bytes to fill C */
-
-  /* Reset restart counter */
-  entropy->restarts_to_go = cinfo->restart_interval;
-}
-
-
-/*
- * Arithmetic MCU decoding.
- * Each of these routines decodes and returns one MCU's worth of
- * arithmetic-compressed coefficients.
- * The coefficients are reordered from zigzag order into natural array order,
- * but are not dequantized.
- *
- * The i'th block of the MCU is stored into the block pointed to by
- * MCU_data[i].  WE ASSUME THIS AREA IS INITIALLY ZEROED BY THE CALLER.
- */
-
-/*
- * MCU decoding for DC initial scan (either spectral selection,
- * or first pass of successive approximation).
- */
-
-METHODDEF(boolean)
-decode_mcu_DC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
-{
-  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
-  JBLOCKROW block;
-  unsigned char *st;
-  int blkn, ci, tbl, sign;
-  int v, m;
-
-  /* Process restart marker if needed */
-  if (cinfo->restart_interval) {
-    if (entropy->restarts_to_go == 0)
-      process_restart(cinfo);
-    entropy->restarts_to_go--;
-  }
-
-  if (entropy->ct == -1) return TRUE;   /* if error do nothing */
-
-  /* Outer loop handles each block in the MCU */
-
-  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
-    block = MCU_data[blkn];
-    ci = cinfo->MCU_membership[blkn];
-    tbl = cinfo->cur_comp_info[ci]->dc_tbl_no;
-
-    /* Sections F.2.4.1 & F.1.4.4.1: Decoding of DC coefficients */
-
-    /* Table F.4: Point to statistics bin S0 for DC coefficient coding */
-    st = entropy->dc_stats[tbl] + entropy->dc_context[ci];
-
-    /* Figure F.19: Decode_DC_DIFF */
-    if (arith_decode(cinfo, st) == 0)
-      entropy->dc_context[ci] = 0;
-    else {
-      /* 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;
-      /* 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 */
-        while (arith_decode(cinfo, st)) {
-          if ((m <<= 1) == 0x8000) {
-            WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
-            entropy->ct = -1;                   /* magnitude overflow */
-            return TRUE;
-          }
-          st += 1;
-        }
-      }
-      /* Section F.1.4.4.1.2: Establish dc_context conditioning category */
-      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))
-        entropy->dc_context[ci] = 12 + (sign * 4); /* large diff category */
-      else
-        entropy->dc_context[ci] = 4 + (sign * 4);  /* small diff category */
-      v = m;
-      /* Figure F.24: Decoding the magnitude bit pattern of v */
-      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;
-    }
-
-    /* Scale and output the DC coefficient (assumes jpeg_natural_order[0]=0) */
-    (*block)[0] = (JCOEF)LEFT_SHIFT(entropy->last_dc_val[ci], cinfo->Al);
-  }
-
-  return TRUE;
-}
-
-
-/*
- * MCU decoding for AC initial scan (either spectral selection,
- * or first pass of successive approximation).
- */
-
-METHODDEF(boolean)
-decode_mcu_AC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
-{
-  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
-  JBLOCKROW block;
-  unsigned char *st;
-  int tbl, sign, k;
-  int v, m;
-
-  /* Process restart marker if needed */
-  if (cinfo->restart_interval) {
-    if (entropy->restarts_to_go == 0)
-      process_restart(cinfo);
-    entropy->restarts_to_go--;
-  }
-
-  if (entropy->ct == -1) return TRUE;   /* if error do nothing */
-
-  /* There is always only one block per MCU */
-  block = MCU_data[0];
-  tbl = cinfo->cur_comp_info[0]->ac_tbl_no;
-
-  /* Sections F.2.4.2 & F.1.4.4.2: Decoding of AC coefficients */
-
-  /* Figure F.20: Decode_AC_coefficients */
-  for (k = cinfo->Ss; k <= cinfo->Se; k++) {
-    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++;
-      if (k > cinfo->Se) {
-        WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
-        entropy->ct = -1;                       /* spectral overflow */
-        return TRUE;
-      }
-    }
-    /* Figure F.21: Decoding nonzero value v */
-    /* Figure F.22: Decoding the sign of v */
-    sign = arith_decode(cinfo, entropy->fixed_bin);
-    st += 2;
-    /* Figure F.23: Decoding the magnitude category of v */
-    if ((m = arith_decode(cinfo, st)) != 0) {
-      if (arith_decode(cinfo, st)) {
-        m <<= 1;
-        st = entropy->ac_stats[tbl] +
-             (k <= cinfo->arith_ac_K[tbl] ? 189 : 217);
-        while (arith_decode(cinfo, st)) {
-          if ((m <<= 1) == 0x8000) {
-            WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
-            entropy->ct = -1;                   /* magnitude overflow */
-            return TRUE;
-          }
-          st += 1;
-        }
-      }
-    }
-    v = m;
-    /* Figure F.24: Decoding the magnitude bit pattern of v */
-    st += 14;
-    while (m >>= 1)
-      if (arith_decode(cinfo, st)) v |= m;
-    v += 1;  if (sign) v = -v;
-    /* Scale and output coefficient in natural (dezigzagged) order */
-    (*block)[jpeg_natural_order[k]] = (JCOEF)((unsigned)v << cinfo->Al);
-  }
-
-  return TRUE;
-}
-
-
-/*
- * MCU decoding for DC successive approximation refinement scan.
- */
-
-METHODDEF(boolean)
-decode_mcu_DC_refine(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
-{
-  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
-  unsigned char *st;
-  int p1, blkn;
-
-  /* Process restart marker if needed */
-  if (cinfo->restart_interval) {
-    if (entropy->restarts_to_go == 0)
-      process_restart(cinfo);
-    entropy->restarts_to_go--;
-  }
-
-  st = entropy->fixed_bin;      /* use fixed probability estimation */
-  p1 = 1 << cinfo->Al;          /* 1 in the bit position being coded */
-
-  /* Outer loop handles each block in the MCU */
-
-  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
-    /* Encoded data is simply the next bit of the two's-complement DC value */
-    if (arith_decode(cinfo, st))
-      MCU_data[blkn][0][0] |= p1;
-  }
-
-  return TRUE;
-}
-
-
-/*
- * MCU decoding for AC successive approximation refinement scan.
- */
-
-METHODDEF(boolean)
-decode_mcu_AC_refine(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
-{
-  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
-  JBLOCKROW block;
-  JCOEFPTR thiscoef;
-  unsigned char *st;
-  int tbl, k, kex;
-  int p1, m1;
-
-  /* Process restart marker if needed */
-  if (cinfo->restart_interval) {
-    if (entropy->restarts_to_go == 0)
-      process_restart(cinfo);
-    entropy->restarts_to_go--;
-  }
-
-  if (entropy->ct == -1) return TRUE;   /* if error do nothing */
-
-  /* There is always only one block per MCU */
-  block = MCU_data[0];
-  tbl = cinfo->cur_comp_info[0]->ac_tbl_no;
-
-  p1 = 1 << cinfo->Al;          /* 1 in the bit position being coded */
-  m1 = (NEG_1) << cinfo->Al;    /* -1 in the bit position being coded */
-
-  /* Establish EOBx (previous stage end-of-block) index */
-  for (kex = cinfo->Se; kex > 0; kex--)
-    if ((*block)[jpeg_natural_order[kex]]) break;
-
-  for (k = cinfo->Ss; k <= cinfo->Se; k++) {
-    st = entropy->ac_stats[tbl] + 3 * (k - 1);
-    if (k > kex)
-      if (arith_decode(cinfo, st)) break;       /* EOB flag */
-    for (;;) {
-      thiscoef = *block + jpeg_natural_order[k];
-      if (*thiscoef) {                          /* previously nonzero coef */
-        if (arith_decode(cinfo, st + 2)) {
-          if (*thiscoef < 0)
-            *thiscoef += (JCOEF)m1;
-          else
-            *thiscoef += (JCOEF)p1;
-        }
-        break;
-      }
-      if (arith_decode(cinfo, st + 1)) {        /* newly nonzero coef */
-        if (arith_decode(cinfo, entropy->fixed_bin))
-          *thiscoef = (JCOEF)m1;
-        else
-          *thiscoef = (JCOEF)p1;
-        break;
-      }
-      st += 3;  k++;
-      if (k > cinfo->Se) {
-        WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
-        entropy->ct = -1;                       /* spectral overflow */
-        return TRUE;
-      }
-    }
-  }
-
-  return TRUE;
-}
-
-
-/*
- * Decode one MCU's worth of arithmetic-compressed coefficients.
- */
-
-METHODDEF(boolean)
-decode_mcu(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
-{
-  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
-  jpeg_component_info *compptr;
-  JBLOCKROW block;
-  unsigned char *st;
-  int blkn, ci, tbl, sign, k;
-  int v, m;
-
-  /* Process restart marker if needed */
-  if (cinfo->restart_interval) {
-    if (entropy->restarts_to_go == 0)
-      process_restart(cinfo);
-    entropy->restarts_to_go--;
-  }
-
-  if (entropy->ct == -1) return TRUE;   /* if error do nothing */
-
-  /* Outer loop handles each block in the MCU */
-
-  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
-    block = MCU_data ? MCU_data[blkn] : NULL;
-    ci = cinfo->MCU_membership[blkn];
-    compptr = cinfo->cur_comp_info[ci];
-
-    /* Sections F.2.4.1 & F.1.4.4.1: Decoding of DC coefficients */
-
-    tbl = compptr->dc_tbl_no;
-
-    /* Table F.4: Point to statistics bin S0 for DC coefficient coding */
-    st = entropy->dc_stats[tbl] + entropy->dc_context[ci];
-
-    /* Figure F.19: Decode_DC_DIFF */
-    if (arith_decode(cinfo, st) == 0)
-      entropy->dc_context[ci] = 0;
-    else {
-      /* 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;
-      /* 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 */
-        while (arith_decode(cinfo, st)) {
-          if ((m <<= 1) == 0x8000) {
-            WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
-            entropy->ct = -1;                   /* magnitude overflow */
-            return TRUE;
-          }
-          st += 1;
-        }
-      }
-      /* Section F.1.4.4.1.2: Establish dc_context conditioning category */
-      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))
-        entropy->dc_context[ci] = 12 + (sign * 4); /* large diff category */
-      else
-        entropy->dc_context[ci] = 4 + (sign * 4);  /* small diff category */
-      v = m;
-      /* Figure F.24: Decoding the magnitude bit pattern of v */
-      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;
-    }
-
-    if (block)
-      (*block)[0] = (JCOEF)entropy->last_dc_val[ci];
-
-    /* Sections F.2.4.2 & F.1.4.4.2: Decoding of AC coefficients */
-
-    tbl = compptr->ac_tbl_no;
-
-    /* Figure F.20: Decode_AC_coefficients */
-    for (k = 1; k <= DCTSIZE2 - 1; k++) {
-      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++;
-        if (k > DCTSIZE2 - 1) {
-          WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
-          entropy->ct = -1;                     /* spectral overflow */
-          return TRUE;
-        }
-      }
-      /* Figure F.21: Decoding nonzero value v */
-      /* Figure F.22: Decoding the sign of v */
-      sign = arith_decode(cinfo, entropy->fixed_bin);
-      st += 2;
-      /* Figure F.23: Decoding the magnitude category of v */
-      if ((m = arith_decode(cinfo, st)) != 0) {
-        if (arith_decode(cinfo, st)) {
-          m <<= 1;
-          st = entropy->ac_stats[tbl] +
-               (k <= cinfo->arith_ac_K[tbl] ? 189 : 217);
-          while (arith_decode(cinfo, st)) {
-            if ((m <<= 1) == 0x8000) {
-              WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
-              entropy->ct = -1;                 /* magnitude overflow */
-              return TRUE;
-            }
-            st += 1;
-          }
-        }
-      }
-      v = m;
-      /* Figure F.24: Decoding the magnitude bit pattern of v */
-      st += 14;
-      while (m >>= 1)
-        if (arith_decode(cinfo, st)) v |= m;
-      v += 1;  if (sign) v = -v;
-      if (block)
-        (*block)[jpeg_natural_order[k]] = (JCOEF)v;
-    }
-  }
-
-  return TRUE;
-}
-
-
-/*
- * Initialize for an arithmetic-compressed scan.
- */
-
-METHODDEF(void)
-start_pass(j_decompress_ptr cinfo)
-{
-  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
-  int ci, tbl;
-  jpeg_component_info *compptr;
-
-  if (cinfo->progressive_mode) {
-    /* Validate progressive scan parameters */
-    if (cinfo->Ss == 0) {
-      if (cinfo->Se != 0)
-        goto bad;
-    } else {
-      /* need not check Ss/Se < 0 since they came from unsigned bytes */
-      if (cinfo->Se < cinfo->Ss || cinfo->Se > DCTSIZE2 - 1)
-        goto bad;
-      /* AC scans may have only one component */
-      if (cinfo->comps_in_scan != 1)
-        goto bad;
-    }
-    if (cinfo->Ah != 0) {
-      /* Successive approximation refinement scan: must have Al = Ah-1. */
-      if (cinfo->Ah - 1 != cinfo->Al)
-        goto bad;
-    }
-    if (cinfo->Al > 13) {       /* need not check for < 0 */
-bad:
-      ERREXIT4(cinfo, JERR_BAD_PROGRESSION,
-               cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al);
-    }
-    /* Update progression status, and verify that scan order is legal.
-     * Note that inter-scan inconsistencies are treated as warnings
-     * not fatal errors ... not clear if this is right way to behave.
-     */
-    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];
-      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)
-          WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, coefi);
-        coef_bit_ptr[coefi] = cinfo->Al;
-      }
-    }
-    /* Select MCU decoding routine */
-    if (cinfo->Ah == 0) {
-      if (cinfo->Ss == 0)
-        entropy->pub.decode_mcu = decode_mcu_DC_first;
-      else
-        entropy->pub.decode_mcu = decode_mcu_AC_first;
-    } else {
-      if (cinfo->Ss == 0)
-        entropy->pub.decode_mcu = decode_mcu_DC_refine;
-      else
-        entropy->pub.decode_mcu = decode_mcu_AC_refine;
-    }
-  } else {
-    /* Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG.
-     * This ought to be an error condition, but we make it a warning.
-     */
-    if (cinfo->Ss != 0 || cinfo->Se != DCTSIZE2 - 1 ||
-        cinfo->Ah != 0 || cinfo->Al != 0)
-      WARNMS(cinfo, JWRN_NOT_SEQUENTIAL);
-    /* Select MCU decoding routine */
-    entropy->pub.decode_mcu = decode_mcu;
-  }
-
-  /* Allocate & initialize requested statistics areas */
-  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
-    compptr = cinfo->cur_comp_info[ci];
-    if (!cinfo->progressive_mode || (cinfo->Ss == 0 && cinfo->Ah == 0)) {
-      tbl = compptr->dc_tbl_no;
-      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);
-      memset(entropy->dc_stats[tbl], 0, DC_STAT_BINS);
-      /* Initialize DC predictions to 0 */
-      entropy->last_dc_val[ci] = 0;
-      entropy->dc_context[ci] = 0;
-    }
-    if (!cinfo->progressive_mode || cinfo->Ss) {
-      tbl = compptr->ac_tbl_no;
-      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);
-      memset(entropy->ac_stats[tbl], 0, AC_STAT_BINS);
-    }
-  }
-
-  /* Initialize arithmetic decoding variables */
-  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;
-}
-
-
-/*
- * Module initialization routine for arithmetic entropy decoding.
- */
-
-GLOBAL(void)
-jinit_arith_decoder(j_decompress_ptr cinfo)
-{
-  arith_entropy_ptr entropy;
-  int i;
-
-  entropy = (arith_entropy_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                sizeof(arith_entropy_decoder));
-  cinfo->entropy = (struct jpeg_entropy_decoder *)entropy;
-  entropy->pub.start_pass = start_pass;
-
-  /* Mark tables unallocated */
-  for (i = 0; i < NUM_ARITH_TBLS; i++) {
-    entropy->dc_stats[i] = NULL;
-    entropy->ac_stats[i] = NULL;
-  }
-
-  /* Initialize index for fixed probability estimation */
-  entropy->fixed_bin[0] = 113;
-
-  if (cinfo->progressive_mode) {
-    /* Create progression status table */
-    int *coef_bit_ptr, ci;
-    cinfo->coef_bits = (int (*)[DCTSIZE2])
-      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                  cinfo->num_components * 2 * 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;
-  }
-}
@@ -1,277 +0,0 @@
-/*
- * jdatadst.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1994-1996, Thomas G. Lane.
- * Modified 2009-2012 by Guido Vollbeding.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2013, 2016, 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains compression data destination routines for the case of
- * emitting JPEG data to memory or to a file (or any stdio stream).
- * While these routines are sufficient for most applications,
- * some will want to use a different destination manager.
- * IMPORTANT: we assume that fwrite() will correctly transcribe an array of
- * JOCTETs into 8-bit-wide elements on external storage.  If char is wider
- * than 8 bits on your machine, you may need to do some tweaking.
- */
-
-/* this is not a core library module, so it doesn't define JPEG_INTERNALS */
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jerror.h"
-
-
-/* Expanded data destination object for stdio output */
-
-typedef struct {
-  struct jpeg_destination_mgr pub; /* public fields */
-
-  FILE *outfile;                /* target stream */
-  JOCTET *buffer;               /* start of buffer */
-} my_destination_mgr;
-
-typedef my_destination_mgr *my_dest_ptr;
-
-#define OUTPUT_BUF_SIZE  4096   /* choose an efficiently fwrite'able size */
-
-
-/* Expanded data destination object for memory output */
-
-typedef struct {
-  struct jpeg_destination_mgr pub; /* public fields */
-
-  unsigned char **outbuffer;    /* target buffer */
-  unsigned long *outsize;
-  unsigned char *newbuffer;     /* newly allocated buffer */
-  JOCTET *buffer;               /* start of buffer */
-  size_t bufsize;
-} my_mem_destination_mgr;
-
-typedef my_mem_destination_mgr *my_mem_dest_ptr;
-
-
-/*
- * Initialize destination --- called by jpeg_start_compress
- * before any data is actually written.
- */
-
-METHODDEF(void)
-init_destination(j_compress_ptr cinfo)
-{
-  my_dest_ptr dest = (my_dest_ptr)cinfo->dest;
-
-  /* Allocate the output buffer --- it will be released when done with image */
-  dest->buffer = (JOCTET *)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                OUTPUT_BUF_SIZE * sizeof(JOCTET));
-
-  dest->pub.next_output_byte = dest->buffer;
-  dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
-}
-
-METHODDEF(void)
-init_mem_destination(j_compress_ptr cinfo)
-{
-  /* no work necessary here */
-}
-
-
-/*
- * Empty the output buffer --- called whenever buffer fills up.
- *
- * In typical applications, this should write the entire output buffer
- * (ignoring the current state of next_output_byte & free_in_buffer),
- * reset the pointer & count to the start of the buffer, and return TRUE
- * indicating that the buffer has been dumped.
- *
- * In applications that need to be able to suspend compression due to output
- * overrun, a FALSE return indicates that the buffer cannot be emptied now.
- * In this situation, the compressor will return to its caller (possibly with
- * an indication that it has not accepted all the supplied scanlines).  The
- * application should resume compression after it has made more room in the
- * output buffer.  Note that there are substantial restrictions on the use of
- * suspension --- see the documentation.
- *
- * When suspending, the compressor will back up to a convenient restart point
- * (typically the start of the current MCU). next_output_byte & free_in_buffer
- * indicate where the restart point will be if the current call returns FALSE.
- * Data beyond this point will be regenerated after resumption, so do not
- * write it out when emptying the buffer externally.
- */
-
-METHODDEF(boolean)
-empty_output_buffer(j_compress_ptr cinfo)
-{
-  my_dest_ptr dest = (my_dest_ptr)cinfo->dest;
-
-  if (fwrite(dest->buffer, 1, OUTPUT_BUF_SIZE, dest->outfile) !=
-      (size_t)OUTPUT_BUF_SIZE)
-    ERREXIT(cinfo, JERR_FILE_WRITE);
-
-  dest->pub.next_output_byte = dest->buffer;
-  dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
-
-  return TRUE;
-}
-
-METHODDEF(boolean)
-empty_mem_output_buffer(j_compress_ptr cinfo)
-{
-  size_t nextsize;
-  JOCTET *nextbuffer;
-  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);
-
-  if (nextbuffer == NULL)
-    ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 10);
-
-  memcpy(nextbuffer, dest->buffer, dest->bufsize);
-
-  free(dest->newbuffer);
-
-  dest->newbuffer = nextbuffer;
-
-  dest->pub.next_output_byte = nextbuffer + dest->bufsize;
-  dest->pub.free_in_buffer = dest->bufsize;
-
-  dest->buffer = nextbuffer;
-  dest->bufsize = nextsize;
-
-  return TRUE;
-}
-
-
-/*
- * Terminate destination --- called by jpeg_finish_compress
- * after all data has been written.  Usually needs to flush buffer.
- *
- * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
- * application must deal with any cleanup that should happen even
- * for error exit.
- */
-
-METHODDEF(void)
-term_destination(j_compress_ptr cinfo)
-{
-  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 */
-  if (datacount > 0) {
-    if (fwrite(dest->buffer, 1, datacount, dest->outfile) != datacount)
-      ERREXIT(cinfo, JERR_FILE_WRITE);
-  }
-  fflush(dest->outfile);
-  /* Make sure we wrote the output file OK */
-  if (ferror(dest->outfile))
-    ERREXIT(cinfo, JERR_FILE_WRITE);
-}
-
-METHODDEF(void)
-term_mem_destination(j_compress_ptr cinfo)
-{
-  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);
-}
-
-
-/*
- * Prepare for output to a stdio stream.
- * The caller must have already opened the stream, and is responsible
- * for closing it after finishing compression.
- */
-
-GLOBAL(void)
-jpeg_stdio_dest(j_compress_ptr cinfo, FILE *outfile)
-{
-  my_dest_ptr dest;
-
-  /* The destination object is made permanent so that multiple JPEG images
-   * can be written to the same file without re-executing jpeg_stdio_dest.
-   */
-  if (cinfo->dest == NULL) {    /* first time for this JPEG object? */
-    cinfo->dest = (struct jpeg_destination_mgr *)
-      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
-                                  sizeof(my_destination_mgr));
-  } else if (cinfo->dest->init_destination != init_destination) {
-    /* It is unsafe to reuse the existing destination manager unless it was
-     * created by this function.  Otherwise, there is no guarantee that the
-     * opaque structure is the right size.  Note that we could just create a
-     * new structure, but the old structure would not be freed until
-     * jpeg_destroy_compress() was called.
-     */
-    ERREXIT(cinfo, JERR_BUFFER_SIZE);
-  }
-
-  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;
-  dest->outfile = outfile;
-}
-
-
-/*
- * Prepare for output to a memory buffer.
- * The caller may supply an own initial buffer with appropriate size.
- * Otherwise, or when the actual data output exceeds the given size,
- * the library adapts the buffer size as necessary.
- * The standard library functions malloc/free are used for allocating
- * larger memory, so the buffer is available to the application after
- * finishing compression, and then the application is responsible for
- * freeing the requested memory.
- * Note:  An initial buffer supplied by the caller is expected to be
- * managed by the application.  The library does not free such buffer
- * when allocating a larger buffer.
- */
-
-GLOBAL(void)
-jpeg_mem_dest(j_compress_ptr cinfo, unsigned char **outbuffer,
-              unsigned long *outsize)
-{
-  my_mem_dest_ptr dest;
-
-  if (outbuffer == NULL || outsize == NULL)     /* sanity check */
-    ERREXIT(cinfo, JERR_BUFFER_SIZE);
-
-  /* The destination object is made permanent so that multiple JPEG images
-   * can be written to the same buffer without re-executing jpeg_mem_dest.
-   */
-  if (cinfo->dest == NULL) {    /* first time for this JPEG object? */
-    cinfo->dest = (struct jpeg_destination_mgr *)
-      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
-                                  sizeof(my_mem_destination_mgr));
-  } else if (cinfo->dest->init_destination != init_mem_destination) {
-    /* It is unsafe to reuse the existing destination manager unless it was
-     * created by this function.
-     */
-    ERREXIT(cinfo, JERR_BUFFER_SIZE);
-  }
-
-  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;
-  dest->outbuffer = outbuffer;
-  dest->outsize = outsize;
-  dest->newbuffer = NULL;
-
-  if (*outbuffer == NULL || *outsize == 0) {
-    /* Allocate initial buffer */
-    dest->newbuffer = *outbuffer = (unsigned char *)malloc(OUTPUT_BUF_SIZE);
-    if (dest->newbuffer == NULL)
-      ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 10);
-    *outsize = OUTPUT_BUF_SIZE;
-  }
-
-  dest->pub.next_output_byte = dest->buffer = *outbuffer;
-  dest->pub.free_in_buffer = dest->bufsize = *outsize;
-}
@@ -1,289 +0,0 @@
-/*
- * jdatasrc.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1994-1996, Thomas G. Lane.
- * Modified 2009-2011 by Guido Vollbeding.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2013, 2016, 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains decompression data source routines for the case of
- * reading JPEG data from memory or from a file (or any stdio stream).
- * While these routines are sufficient for most applications,
- * some will want to use a different source manager.
- * IMPORTANT: we assume that fread() will correctly transcribe an array of
- * JOCTETs from 8-bit-wide elements on external storage.  If char is wider
- * than 8 bits on your machine, you may need to do some tweaking.
- */
-
-/* this is not a core library module, so it doesn't define JPEG_INTERNALS */
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jerror.h"
-
-
-/* Expanded data source object for stdio input */
-
-typedef struct {
-  struct jpeg_source_mgr pub;   /* public fields */
-
-  FILE *infile;                 /* source stream */
-  JOCTET *buffer;               /* start of buffer */
-  boolean start_of_file;        /* have we gotten any data yet? */
-} my_source_mgr;
-
-typedef my_source_mgr *my_src_ptr;
-
-#define INPUT_BUF_SIZE  4096    /* choose an efficiently fread'able size */
-
-
-/*
- * Initialize source --- called by jpeg_read_header
- * before any data is actually read.
- */
-
-METHODDEF(void)
-init_source(j_decompress_ptr cinfo)
-{
-  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.
-   * This is correct behavior for reading a series of images from one source.
-   */
-  src->start_of_file = TRUE;
-}
-
-METHODDEF(void)
-init_mem_source(j_decompress_ptr cinfo)
-{
-  /* no work necessary here */
-}
-
-
-/*
- * Fill the input buffer --- called whenever buffer is emptied.
- *
- * In typical applications, this should read fresh data into the buffer
- * (ignoring the current state of next_input_byte & bytes_in_buffer),
- * reset the pointer & count to the start of the buffer, and return TRUE
- * indicating that the buffer has been reloaded.  It is not necessary to
- * fill the buffer entirely, only to obtain at least one more byte.
- *
- * There is no such thing as an EOF return.  If the end of the file has been
- * reached, the routine has a choice of ERREXIT() or inserting fake data into
- * the buffer.  In most cases, generating a warning message and inserting a
- * fake EOI marker is the best course of action --- this will allow the
- * decompressor to output however much of the image is there.  However,
- * the resulting error message is misleading if the real problem is an empty
- * input file, so we handle that case specially.
- *
- * In applications that need to be able to suspend compression due to input
- * not being available yet, a FALSE return indicates that no more data can be
- * obtained right now, but more may be forthcoming later.  In this situation,
- * the decompressor will return to its caller (with an indication of the
- * number of scanlines it has read, if any).  The application should resume
- * decompression after it has loaded more data into the input buffer.  Note
- * that there are substantial restrictions on the use of suspension --- see
- * the documentation.
- *
- * When suspending, the decompressor will back up to a convenient restart point
- * (typically the start of the current MCU). next_input_byte & bytes_in_buffer
- * indicate where the restart point will be if the current call returns FALSE.
- * Data beyond this point must be rescanned after resumption, so move it to
- * the front of the buffer rather than discarding it.
- */
-
-METHODDEF(boolean)
-fill_input_buffer(j_decompress_ptr cinfo)
-{
-  my_src_ptr src = (my_src_ptr)cinfo->src;
-  size_t nbytes;
-
-  nbytes = fread(src->buffer, 1, INPUT_BUF_SIZE, src->infile);
-
-  if (nbytes <= 0) {
-    if (src->start_of_file)     /* Treat empty input file as fatal error */
-      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;
-    nbytes = 2;
-  }
-
-  src->pub.next_input_byte = src->buffer;
-  src->pub.bytes_in_buffer = nbytes;
-  src->start_of_file = FALSE;
-
-  return TRUE;
-}
-
-METHODDEF(boolean)
-fill_mem_input_buffer(j_decompress_ptr cinfo)
-{
-  static const JOCTET mybuffer[4] = {
-    (JOCTET)0xFF, (JOCTET)JPEG_EOI, 0, 0
-  };
-
-  /* The whole JPEG data is expected to reside in the supplied memory
-   * buffer, so any request for more data beyond the given buffer size
-   * is treated as an error.
-   */
-  WARNMS(cinfo, JWRN_JPEG_EOF);
-
-  /* Insert a fake EOI marker */
-
-  cinfo->src->next_input_byte = mybuffer;
-  cinfo->src->bytes_in_buffer = 2;
-
-  return TRUE;
-}
-
-
-/*
- * Skip data --- used to skip over a potentially large amount of
- * uninteresting data (such as an APPn marker).
- *
- * Writers of suspendable-input applications must note that skip_input_data
- * is not granted the right to give a suspension return.  If the skip extends
- * beyond the data currently in the buffer, the buffer can be marked empty so
- * that the next read will cause a fill_input_buffer call that can suspend.
- * Arranging for additional bytes to be discarded before reloading the input
- * buffer is the application writer's problem.
- */
-
-METHODDEF(void)
-skip_input_data(j_decompress_ptr cinfo, long num_bytes)
-{
-  struct jpeg_source_mgr *src = cinfo->src;
-
-  /* Just a dumb implementation for now.  Could use fseek() except
-   * it doesn't work on pipes.  Not clear that being smart is worth
-   * any trouble anyway --- large skips are infrequent.
-   */
-  if (num_bytes > 0) {
-    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;
-  }
-}
-
-
-/*
- * An additional method that can be provided by data source modules is the
- * resync_to_restart method for error recovery in the presence of RST markers.
- * For the moment, this source module just uses the default resync method
- * provided by the JPEG library.  That method assumes that no backtracking
- * is possible.
- */
-
-
-/*
- * Terminate source --- called by jpeg_finish_decompress
- * after all data has been read.  Often a no-op.
- *
- * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
- * application must deal with any cleanup that should happen even
- * for error exit.
- */
-
-METHODDEF(void)
-term_source(j_decompress_ptr cinfo)
-{
-  /* no work necessary here */
-}
-
-
-/*
- * Prepare for input from a stdio stream.
- * The caller must have already opened the stream, and is responsible
- * for closing it after finishing decompression.
- */
-
-GLOBAL(void)
-jpeg_stdio_src(j_decompress_ptr cinfo, FILE *infile)
-{
-  my_src_ptr src;
-
-  /* The source object and input buffer are made permanent so that a series
-   * of JPEG images can be read from the same file by calling jpeg_stdio_src
-   * only before the first one.  (If we discarded the buffer at the end of
-   * one image, we'd likely lose the start of the next one.)
-   */
-  if (cinfo->src == NULL) {     /* first time for this JPEG object? */
-    cinfo->src = (struct jpeg_source_mgr *)
-      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
-                                  sizeof(my_source_mgr));
-    src = (my_src_ptr)cinfo->src;
-    src->buffer = (JOCTET *)
-      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
-                                  INPUT_BUF_SIZE * sizeof(JOCTET));
-  } else if (cinfo->src->init_source != init_source) {
-    /* It is unsafe to reuse the existing source manager unless it was created
-     * by this function.  Otherwise, there is no guarantee that the opaque
-     * structure is the right size.  Note that we could just create a new
-     * structure, but the old structure would not be freed until
-     * jpeg_destroy_decompress() was called.
-     */
-    ERREXIT(cinfo, JERR_BUFFER_SIZE);
-  }
-
-  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;
-  src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */
-  src->pub.term_source = term_source;
-  src->infile = infile;
-  src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */
-  src->pub.next_input_byte = NULL; /* until buffer loaded */
-}
-
-
-/*
- * Prepare for input from a supplied memory buffer.
- * The buffer must contain the whole JPEG data.
- */
-
-GLOBAL(void)
-jpeg_mem_src(j_decompress_ptr cinfo, const unsigned char *inbuffer,
-             unsigned long insize)
-{
-  struct jpeg_source_mgr *src;
-
-  if (inbuffer == NULL || insize == 0)  /* Treat empty input as fatal error */
-    ERREXIT(cinfo, JERR_INPUT_EMPTY);
-
-  /* The source object is made permanent so that a series of JPEG images
-   * can be read from the same buffer by calling jpeg_mem_src only before
-   * the first one.
-   */
-  if (cinfo->src == NULL) {     /* first time for this JPEG object? */
-    cinfo->src = (struct jpeg_source_mgr *)
-      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
-                                  sizeof(struct jpeg_source_mgr));
-  } else if (cinfo->src->init_source != init_mem_source) {
-    /* It is unsafe to reuse the existing source manager unless it was created
-     * by this function.
-     */
-    ERREXIT(cinfo, JERR_BUFFER_SIZE);
-  }
-
-  src = cinfo->src;
-  src->init_source = init_mem_source;
-  src->fill_input_buffer = fill_mem_input_buffer;
-  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;
-}
@@ -1,885 +0,0 @@
-/*
- * jdcoefct.c
- *
- * This file was part of the Independent JPEG Group's software:
- * 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, 2022-2023, D. R. Commander.
- * Copyright (C) 2015, 2020, Google, Inc.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains the coefficient buffer controller for decompression.
- * This controller is the top level of the lossy JPEG decompressor proper.
- * The coefficient buffer lies between entropy decoding and inverse-DCT steps.
- *
- * In buffered-image mode, this controller is the interface between
- * input-oriented processing and output-oriented processing.
- * Also, the input side (only) is used when reading a file for transcoding.
- */
-
-#include "jinclude.h"
-#include "jdcoefct.h"
-#include "jpegapicomp.h"
-#include "jsamplecomp.h"
-
-
-/* Forward declarations */
-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);
-#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);
-#endif
-
-
-/*
- * Initialize for an input processing pass.
- */
-
-METHODDEF(void)
-start_input_pass(j_decompress_ptr cinfo)
-{
-  cinfo->input_iMCU_row = 0;
-  start_iMCU_row(cinfo);
-}
-
-
-/*
- * Initialize for an output processing pass.
- */
-
-METHODDEF(void)
-start_output_pass(j_decompress_ptr cinfo)
-{
-#ifdef BLOCK_SMOOTHING_SUPPORTED
-  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) {
-    if (cinfo->do_block_smoothing && smoothing_ok(cinfo))
-      coef->pub._decompress_data = decompress_smooth_data;
-    else
-      coef->pub._decompress_data = decompress_data;
-  }
-#endif
-  cinfo->output_iMCU_row = 0;
-}
-
-
-/*
- * Decompress and return some data in the single-pass case.
- * Always attempts to emit one fully interleaved MCU row ("iMCU" row).
- * Input and output must run in lockstep since we have only a one-MCU buffer.
- * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
- *
- * NB: output_buf contains a plane for each component in image,
- * which we index according to the component's SOF position.
- */
-
-METHODDEF(int)
-decompress_onepass(j_decompress_ptr cinfo, _JSAMPIMAGE output_buf)
-{
-  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;
-  int blkn, ci, xindex, yindex, yoffset, useful_width;
-  _JSAMPARRAY output_ptr;
-  JDIMENSION start_col, output_col;
-  jpeg_component_info *compptr;
-  _inverse_DCT_method_ptr inverse_DCT;
-
-  /* Loop to process as much as one whole iMCU row */
-  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
-       yoffset++) {
-    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)) {
-        /* Suspension forced; update state counters and exit */
-        coef->MCU_vert_offset = yoffset;
-        coef->MCU_ctr = MCU_col_num;
-        return JPEG_SUSPENDED;
-      }
-
-      /* Only perform the IDCT on blocks that are contained within the desired
-       * cropping region.
-       */
-      if (MCU_col_num >= cinfo->master->first_iMCU_col &&
-          MCU_col_num <= cinfo->master->last_iMCU_col) {
-        /* Determine where data should go in output_buf and do the IDCT thing.
-         * We skip dummy blocks at the right and bottom edges (but blkn gets
-         * 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 */
-        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) {
-            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;
-          output_ptr = output_buf[compptr->component_index] +
-                       yoffset * compptr->_DCT_scaled_size;
-          start_col = (MCU_col_num - cinfo->master->first_iMCU_col) *
-                      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) {
-              output_col = start_col;
-              for (xindex = 0; xindex < useful_width; xindex++) {
-                (*inverse_DCT) (cinfo, compptr,
-                                (JCOEFPTR)coef->MCU_buffer[blkn + xindex],
-                                output_ptr, output_col);
-                output_col += compptr->_DCT_scaled_size;
-              }
-            }
-            blkn += compptr->MCU_width;
-            output_ptr += compptr->_DCT_scaled_size;
-          }
-        }
-      }
-    }
-    /* Completed an MCU row, but perhaps not an iMCU row */
-    coef->MCU_ctr = 0;
-  }
-  /* Completed the iMCU row, advance counters for next one */
-  cinfo->output_iMCU_row++;
-  if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) {
-    start_iMCU_row(cinfo);
-    return JPEG_ROW_COMPLETED;
-  }
-  /* Completed the scan */
-  (*cinfo->inputctl->finish_input_pass) (cinfo);
-  return JPEG_SCAN_COMPLETED;
-}
-
-
-/*
- * Dummy consume-input routine for single-pass operation.
- */
-
-METHODDEF(int)
-dummy_consume_data(j_decompress_ptr cinfo)
-{
-  return JPEG_SUSPENDED;        /* Always indicate nothing was done */
-}
-
-
-#ifdef D_MULTISCAN_FILES_SUPPORTED
-
-/*
- * Consume input data and store it in the full-image coefficient buffer.
- * We read as much as one fully interleaved MCU row ("iMCU" row) per call,
- * ie, v_samp_factor block rows for each component in the scan.
- * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
- */
-
-METHODDEF(int)
-consume_data(j_decompress_ptr cinfo)
-{
-  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;
-  JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
-  JBLOCKROW buffer_ptr;
-  jpeg_component_info *compptr;
-
-  /* Align the virtual buffers for the components used in this scan. */
-  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],
-       cinfo->input_iMCU_row * compptr->v_samp_factor,
-       (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.
-     */
-  }
-
-  /* Loop to process one whole iMCU row */
-  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
-       yoffset++) {
-    for (MCU_col_num = coef->MCU_ctr; MCU_col_num < cinfo->MCUs_per_row;
-         MCU_col_num++) {
-      /* Construct list of pointers to DCT blocks belonging to this 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];
-        start_col = MCU_col_num * compptr->MCU_width;
-        for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
-          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)) {
-        /* Suspension forced; update state counters and exit */
-        coef->MCU_vert_offset = yoffset;
-        coef->MCU_ctr = MCU_col_num;
-        return JPEG_SUSPENDED;
-      }
-    }
-    /* Completed an MCU row, but perhaps not an iMCU row */
-    coef->MCU_ctr = 0;
-  }
-  /* Completed the iMCU row, advance counters for next one */
-  if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) {
-    start_iMCU_row(cinfo);
-    return JPEG_ROW_COMPLETED;
-  }
-  /* Completed the scan */
-  (*cinfo->inputctl->finish_input_pass) (cinfo);
-  return JPEG_SCAN_COMPLETED;
-}
-
-
-/*
- * Decompress and return some data in the multi-pass case.
- * Always attempts to emit one fully interleaved MCU row ("iMCU" row).
- * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
- *
- * NB: output_buf contains a plane for each component in image.
- */
-
-METHODDEF(int)
-decompress_data(j_decompress_ptr cinfo, _JSAMPIMAGE output_buf)
-{
-  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;
-  JBLOCKARRAY buffer;
-  JBLOCKROW buffer_ptr;
-  _JSAMPARRAY output_ptr;
-  JDIMENSION output_col;
-  jpeg_component_info *compptr;
-  _inverse_DCT_method_ptr inverse_DCT;
-
-  /* Force some input to be done if we are getting ahead of the input. */
-  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)
-      return JPEG_SUSPENDED;
-  }
-
-  /* OK, output from the virtual arrays. */
-  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)
-      continue;
-    /* Align the virtual buffer for this component. */
-    buffer = (*cinfo->mem->access_virt_barray)
-      ((j_common_ptr)cinfo, coef->whole_image[ci],
-       cinfo->output_iMCU_row * compptr->v_samp_factor,
-       (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);
-      if (block_rows == 0) block_rows = compptr->v_samp_factor;
-    }
-    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];
-      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);
-        buffer_ptr++;
-        output_col += compptr->_DCT_scaled_size;
-      }
-      output_ptr += compptr->_DCT_scaled_size;
-    }
-  }
-
-  if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows)
-    return JPEG_ROW_COMPLETED;
-  return JPEG_SCAN_COMPLETED;
-}
-
-#endif /* D_MULTISCAN_FILES_SUPPORTED */
-
-
-#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.
- * 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 */
-#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.
- * We also latch the current states of the coef_bits[] entries for the
- * AC coefficients; otherwise, if the input side of the decompressor
- * advances into a new scan, we might think the coefficients are known
- * more accurately than they really are.
- */
-
-LOCAL(boolean)
-smoothing_ok(j_decompress_ptr cinfo)
-{
-  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;
-
-  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 *
-                                  (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. */
-    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)
-      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;
-      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;
-}
-
-
-/*
- * Variant of decompress_data for use when doing block smoothing.
- */
-
-METHODDEF(int)
-decompress_smooth_data(j_decompress_ptr cinfo, _JSAMPIMAGE output_buf)
-{
-  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, image_block_row,
-    image_block_rows;
-  JBLOCKARRAY buffer;
-  JBLOCKROW buffer_ptr, prev_prev_block_row, prev_block_row;
-  JBLOCKROW next_block_row, next_next_block_row;
-  _JSAMPARRAY output_ptr;
-  JDIMENSION output_col;
-  jpeg_component_info *compptr;
-  _inverse_DCT_method_ptr inverse_DCT;
-  boolean change_dc;
-  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;
-  int Al, pred;
-
-  /* Keep a local variable to avoid looking it up more than once */
-  workspace = coef->workspace;
-
-  /* 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) {
-    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
-       * values are up to date.
-       */
-      JDIMENSION delta = (cinfo->Ss == 0) ? 2 : 0;
-      if (cinfo->input_iMCU_row > cinfo->output_iMCU_row + delta)
-        break;
-    }
-    if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)
-      return JPEG_SUSPENDED;
-  }
-
-  /* OK, output from the virtual arrays. */
-  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)
-      continue;
-    /* Count non-dummy DCT block rows in this iMCU row. */
-    if (cinfo->output_iMCU_row + 1 < last_iMCU_row) {
-      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) {
-      block_rows = compptr->v_samp_factor;
-      access_rows = block_rows * 2; /* this and next iMCU row */
-    } 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);
-      if (block_rows == 0) block_rows = compptr->v_samp_factor;
-      access_rows = block_rows; /* this iMCU row only */
-    }
-    /* 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 */
-      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) {
-      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 - 1) * compptr->v_samp_factor,
-         (JDIMENSION)access_rows, FALSE);
-      buffer += compptr->v_samp_factor; /* point to current iMCU row */
-    } else {
-      buffer = (*cinfo->mem->access_virt_barray)
-        ((j_common_ptr)cinfo, coef->whole_image[ci],
-         (JDIMENSION)0, (JDIMENSION)access_rows, FALSE);
-    }
-    /* 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;
-
-    quanttbl = compptr->quant_table;
-    Q00 = quanttbl->quantval[0];
-    Q01 = quanttbl->quantval[Q01_POS];
-    Q10 = quanttbl->quantval[Q10_POS];
-    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. */
-    image_block_rows = block_rows * cinfo->total_iMCU_rows;
-    for (block_row = 0; block_row < block_rows; block_row++) {
-      image_block_row = cinfo->output_iMCU_row * block_rows + block_row;
-      buffer_ptr = buffer[block_row] + cinfo->master->first_MCU_col[ci];
-
-      if (image_block_row > 0)
-        prev_block_row =
-          buffer[block_row - 1] + cinfo->master->first_MCU_col[ci];
-      else
-        prev_block_row = buffer_ptr;
-
-      if (image_block_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 (image_block_row < image_block_rows - 1)
-        next_block_row =
-          buffer[block_row + 1] + cinfo->master->first_MCU_col[ci];
-      else
-        next_block_row = buffer_ptr;
-
-      if (image_block_row < image_block_rows - 2)
-        next_next_block_row =
-          buffer[block_row + 2] + cinfo->master->first_MCU_col[ci];
-      else
-        next_next_block_row = next_block_row;
-
-      /* 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.
-       */
-      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];
-      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);
-        /* Update DC values */
-        if (block_num == cinfo->master->first_MCU_col[ci] &&
-            block_num < last_block_column) {
-          DC04 = DC05 = (int)prev_prev_block_row[1][0];
-          DC09 = DC10 = (int)prev_block_row[1][0];
-          DC14 = DC15 = (int)buffer_ptr[1][0];
-          DC19 = DC20 = (int)next_block_row[1][0];
-          DC24 = DC25 = (int)next_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.
-         */
-        /* 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 (num >= 0) {
-            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 = -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 (num >= 0) {
-            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 = -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 (num >= 0) {
-            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 = -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 (num >= 0) {
-            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 = -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 (num >= 0) {
-            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 = -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);
-        /* 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++;
-        output_col += compptr->_DCT_scaled_size;
-      }
-      output_ptr += compptr->_DCT_scaled_size;
-    }
-  }
-
-  if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows)
-    return JPEG_ROW_COMPLETED;
-  return JPEG_SCAN_COMPLETED;
-}
-
-#endif /* BLOCK_SMOOTHING_SUPPORTED */
-
-
-/*
- * Initialize coefficient buffer controller.
- */
-
-GLOBAL(void)
-_jinit_d_coef_controller(j_decompress_ptr cinfo, boolean need_full_buffer)
-{
-  my_coef_ptr coef;
-
-  if (cinfo->data_precision != BITS_IN_JSAMPLE)
-    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-
-  coef = (my_coef_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                sizeof(my_coef_controller));
-  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
-  coef->coef_bits_latch = NULL;
-#endif
-
-  /* Create the coefficient buffer. */
-  if (need_full_buffer) {
-#ifdef D_MULTISCAN_FILES_SUPPORTED
-    /* Allocate a full-image virtual array for each component, */
-    /* padded to a multiple of samp_factor DCT blocks in each direction. */
-    /* Note we ask for a pre-zeroed array. */
-    int ci, access_rows;
-    jpeg_component_info *compptr;
-
-    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-         ci++, compptr++) {
-      access_rows = compptr->v_samp_factor;
-#ifdef BLOCK_SMOOTHING_SUPPORTED
-      /* If block smoothing could be used, need a bigger window */
-      if (cinfo->progressive_mode)
-        access_rows *= 5;
-#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);
-    }
-    coef->pub.consume_data = consume_data;
-    coef->pub._decompress_data = decompress_data;
-    coef->pub.coef_arrays = coef->whole_image; /* link to virtual arrays */
-#else
-    ERREXIT(cinfo, JERR_NOT_COMPILED);
-#endif
-  } else {
-    /* We only need a single-MCU buffer. */
-    JBLOCKROW buffer;
-    int i;
-
-    buffer = (JBLOCKROW)
-      (*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;
-    }
-    coef->pub.consume_data = dummy_consume_data;
-    coef->pub._decompress_data = decompress_onepass;
-    coef->pub.coef_arrays = NULL; /* flag for no virtual arrays */
-  }
-
-  /* Allocate the workspace buffer */
-  coef->workspace = (JCOEF *)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                sizeof(JCOEF) * DCTSIZE2);
-}
@@ -1,88 +0,0 @@
-/*
- * jdcoefct.h
- *
- * This file was part of the Independent JPEG Group's software:
- * 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.
- * Copyright (C) 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- */
-
-#define JPEG_INTERNALS
-#include "jpeglib.h"
-
-
-#if BITS_IN_JSAMPLE != 16 || defined(D_LOSSLESS_SUPPORTED)
-
-/* Block smoothing is only applicable for progressive JPEG, so: */
-#ifndef D_PROGRESSIVE_SUPPORTED
-#undef BLOCK_SMOOTHING_SUPPORTED
-#endif
-
-
-/* Private buffer controller object */
-
-typedef struct {
-  struct jpeg_d_coef_controller pub; /* public fields */
-
-  /* These variables keep track of the current location of the input side. */
-  /* cinfo->input_iMCU_row is also used for this. */
-  JDIMENSION MCU_ctr;           /* counts MCUs processed in current row */
-  int MCU_vert_offset;          /* counts MCU rows within iMCU row */
-  int MCU_rows_per_iMCU_row;    /* number of such rows needed */
-
-  /* The output side's location is represented by cinfo->output_iMCU_row. */
-
-  /* In single-pass modes, it's sufficient to buffer just one MCU.
-   * We allocate a workspace of D_MAX_BLOCKS_IN_MCU coefficient blocks,
-   * and let the entropy decoder write into that workspace each time.
-   * In multi-pass modes, this array points to the current MCU's blocks
-   * within the virtual arrays; it is used only by the input side.
-   */
-  JBLOCKROW MCU_buffer[D_MAX_BLOCKS_IN_MCU];
-
-  /* Temporary workspace for one MCU */
-  JCOEF *workspace;
-
-#ifdef D_MULTISCAN_FILES_SUPPORTED
-  /* In multi-pass modes, we need a virtual block array for each component. */
-  jvirt_barray_ptr whole_image[MAX_COMPONENTS];
-#endif
-
-#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] */
-#endif
-} my_coef_controller;
-
-typedef my_coef_controller *my_coef_ptr;
-
-
-LOCAL(void)
-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;
-
-  /* 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.
-   * But at the bottom of the image, process only what's left.
-   */
-  if (cinfo->comps_in_scan > 1) {
-    coef->MCU_rows_per_iMCU_row = 1;
-  } else {
-    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;
-  }
-
-  coef->MCU_ctr = 0;
-  coef->MCU_vert_offset = 0;
-}
-
-#endif /* BITS_IN_JSAMPLE != 16 || defined(D_LOSSLESS_SUPPORTED) */
@@ -1,392 +0,0 @@
-/*
- * jdcol565.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1991-1997, Thomas G. Lane.
- * Modifications:
- * Copyright (C) 2013, Linaro Limited.
- * Copyright (C) 2014-2015, 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains output colorspace conversion routines.
- */
-
-/* This file is included by jdcolor.c */
-
-
-INLINE
-LOCAL(void)
-ycc_rgb565_convert_internal(j_decompress_ptr cinfo, _JSAMPIMAGE input_buf,
-                            JDIMENSION input_row, _JSAMPARRAY output_buf,
-                            int num_rows)
-{
-#if BITS_IN_JSAMPLE != 16
-  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 = (_JSAMPLE *)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) {
-    JLONG rgb;
-    unsigned int r, g, b;
-    inptr0 = input_buf[0][input_row];
-    inptr1 = input_buf[1][input_row];
-    inptr2 = input_buf[2][input_row];
-    input_row++;
-    outptr = *output_buf++;
-
-    if (PACK_NEED_ALIGNMENT(outptr)) {
-      y  = *inptr0++;
-      cb = *inptr1++;
-      cr = *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;
-      outptr += 2;
-      num_cols--;
-    }
-    for (col = 0; col < (num_cols >> 1); col++) {
-      y  = *inptr0++;
-      cb = *inptr1++;
-      cr = *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++;
-      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_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
-
-      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
-      outptr += 4;
-    }
-    if (num_cols & 1) {
-      y  = *inptr0;
-      cb = *inptr1;
-      cr = *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;
-    }
-  }
-#else
-  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-#endif
-}
-
-
-INLINE
-LOCAL(void)
-ycc_rgb565D_convert_internal(j_decompress_ptr cinfo, _JSAMPIMAGE input_buf,
-                             JDIMENSION input_row, _JSAMPARRAY output_buf,
-                             int num_rows)
-{
-#if BITS_IN_JSAMPLE != 16
-  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 = (_JSAMPLE *)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
-
-  while (--num_rows >= 0) {
-    JLONG rgb;
-    unsigned int r, g, b;
-
-    inptr0 = input_buf[0][input_row];
-    inptr1 = input_buf[1][input_row];
-    inptr2 = input_buf[2][input_row];
-    input_row++;
-    outptr = *output_buf++;
-    if (PACK_NEED_ALIGNMENT(outptr)) {
-      y  = *inptr0++;
-      cb = *inptr1++;
-      cr = *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;
-      outptr += 2;
-      num_cols--;
-    }
-    for (col = 0; col < (num_cols >> 1); col++) {
-      y  = *inptr0++;
-      cb = *inptr1++;
-      cr = *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)];
-      d0 = DITHER_ROTATE(d0);
-      rgb = PACK_SHORT_565(r, g, b);
-
-      y  = *inptr0++;
-      cb = *inptr1++;
-      cr = *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)];
-      d0 = DITHER_ROTATE(d0);
-      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
-
-      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
-      outptr += 4;
-    }
-    if (num_cols & 1) {
-      y  = *inptr0;
-      cb = *inptr1;
-      cr = *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;
-    }
-  }
-#else
-  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-#endif
-}
-
-
-INLINE
-LOCAL(void)
-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;
-  register JDIMENSION col;
-  JDIMENSION num_cols = cinfo->output_width;
-  SHIFT_TEMPS
-
-  while (--num_rows >= 0) {
-    JLONG rgb;
-    unsigned int r, g, b;
-
-    inptr0 = input_buf[0][input_row];
-    inptr1 = input_buf[1][input_row];
-    inptr2 = input_buf[2][input_row];
-    input_row++;
-    outptr = *output_buf++;
-    if (PACK_NEED_ALIGNMENT(outptr)) {
-      r = *inptr0++;
-      g = *inptr1++;
-      b = *inptr2++;
-      rgb = PACK_SHORT_565(r, g, b);
-      *(INT16 *)outptr = (INT16)rgb;
-      outptr += 2;
-      num_cols--;
-    }
-    for (col = 0; col < (num_cols >> 1); col++) {
-      r = *inptr0++;
-      g = *inptr1++;
-      b = *inptr2++;
-      rgb = PACK_SHORT_565(r, g, b);
-
-      r = *inptr0++;
-      g = *inptr1++;
-      b = *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;
-      rgb = PACK_SHORT_565(r, g, b);
-      *(INT16 *)outptr = (INT16)rgb;
-    }
-  }
-}
-
-
-INLINE
-LOCAL(void)
-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 = (_JSAMPLE *)cinfo->sample_range_limit;
-  JDIMENSION num_cols = cinfo->output_width;
-  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];
-  SHIFT_TEMPS
-
-  while (--num_rows >= 0) {
-    JLONG rgb;
-    unsigned int r, g, b;
-
-    inptr0 = input_buf[0][input_row];
-    inptr1 = input_buf[1][input_row];
-    inptr2 = input_buf[2][input_row];
-    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)];
-      rgb = PACK_SHORT_565(r, g, b);
-      *(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)];
-      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)];
-      d0 = DITHER_ROTATE(d0);
-      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
-
-      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
-      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)];
-      rgb = PACK_SHORT_565(r, g, b);
-      *(INT16 *)outptr = (INT16)rgb;
-    }
-  }
-}
-
-
-INLINE
-LOCAL(void)
-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;
-  JDIMENSION num_cols = cinfo->output_width;
-
-  while (--num_rows >= 0) {
-    JLONG rgb;
-    unsigned int g;
-
-    inptr = input_buf[0][input_row++];
-    outptr = *output_buf++;
-    if (PACK_NEED_ALIGNMENT(outptr)) {
-      g = *inptr++;
-      rgb = PACK_SHORT_565(g, g, g);
-      *(INT16 *)outptr = (INT16)rgb;
-      outptr += 2;
-      num_cols--;
-    }
-    for (col = 0; col < (num_cols >> 1); col++) {
-      g = *inptr++;
-      rgb = PACK_SHORT_565(g, g, g);
-      g = *inptr++;
-      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(g, g, g));
-      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
-      outptr += 4;
-    }
-    if (num_cols & 1) {
-      g = *inptr;
-      rgb = PACK_SHORT_565(g, g, g);
-      *(INT16 *)outptr = (INT16)rgb;
-    }
-  }
-}
-
-
-INLINE
-LOCAL(void)
-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 = (_JSAMPLE *)cinfo->sample_range_limit;
-  JDIMENSION num_cols = cinfo->output_width;
-  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];
-
-  while (--num_rows >= 0) {
-    JLONG rgb;
-    unsigned int g;
-
-    inptr = input_buf[0][input_row++];
-    outptr = *output_buf++;
-    if (PACK_NEED_ALIGNMENT(outptr)) {
-      g = *inptr++;
-      g = range_limit[DITHER_565_R(g, d0)];
-      rgb = PACK_SHORT_565(g, g, g);
-      *(INT16 *)outptr = (INT16)rgb;
-      outptr += 2;
-      num_cols--;
-    }
-    for (col = 0; col < (num_cols >> 1); col++) {
-      g = *inptr++;
-      g = range_limit[DITHER_565_R(g, d0)];
-      rgb = PACK_SHORT_565(g, g, g);
-      d0 = DITHER_ROTATE(d0);
-
-      g = *inptr++;
-      g = range_limit[DITHER_565_R(g, d0)];
-      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(g, g, g));
-      d0 = DITHER_ROTATE(d0);
-
-      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
-      outptr += 4;
-    }
-    if (num_cols & 1) {
-      g = *inptr;
-      g = range_limit[DITHER_565_R(g, d0)];
-      rgb = PACK_SHORT_565(g, g, g);
-      *(INT16 *)outptr = (INT16)rgb;
-    }
-  }
-}
@@ -1,145 +0,0 @@
-/*
- * jdcolext.c
- *
- * 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, 2015, 2022-2023, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains output colorspace conversion routines.
- */
-
-
-/* This file is included by jdcolor.c */
-
-
-/*
- * Convert some rows of samples to the output colorspace.
- *
- * Note that we change from noninterleaved, one-plane-per-component format
- * to interleaved-pixel format.  The output buffer is therefore three times
- * as wide as the input buffer.
- * A starting row offset is provided only for the input buffer.  The caller
- * can easily adjust the passed output_buf value to accommodate any row
- * offset required on that side.
- */
-
-INLINE
-LOCAL(void)
-ycc_rgb_convert_internal(j_decompress_ptr cinfo, _JSAMPIMAGE input_buf,
-                         JDIMENSION input_row, _JSAMPARRAY output_buf,
-                         int num_rows)
-{
-#if BITS_IN_JSAMPLE != 16
-  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 = (_JSAMPLE *)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) {
-    inptr0 = input_buf[0][input_row];
-    inptr1 = input_buf[1][input_row];
-    inptr2 = input_buf[2][input_row];
-    input_row++;
-    outptr = *output_buf++;
-    for (col = 0; col < num_cols; col++) {
-      y  = inptr0[col];
-      cb = inptr1[col];
-      cr = 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))];
-      outptr[RGB_BLUE] =  range_limit[y + Cbbtab[cb]];
-      /* Set unused byte to _MAXJSAMPLE so it can be interpreted as an */
-      /* opaque alpha channel value */
-#ifdef RGB_ALPHA
-      outptr[RGB_ALPHA] = _MAXJSAMPLE;
-#endif
-      outptr += RGB_PIXELSIZE;
-    }
-  }
-#else
-  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-#endif
-}
-
-
-/*
- * Convert grayscale to RGB: just duplicate the graylevel three times.
- * This is provided to support applications that don't want to cope
- * with grayscale as a separate case.
- */
-
-INLINE
-LOCAL(void)
-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;
-  JDIMENSION num_cols = cinfo->output_width;
-
-  while (--num_rows >= 0) {
-    inptr = input_buf[0][input_row++];
-    outptr = *output_buf++;
-    for (col = 0; col < num_cols; col++) {
-      outptr[RGB_RED] = outptr[RGB_GREEN] = outptr[RGB_BLUE] = inptr[col];
-      /* Set unused byte to _MAXJSAMPLE so it can be interpreted as an */
-      /* opaque alpha channel value */
-#ifdef RGB_ALPHA
-      outptr[RGB_ALPHA] = _MAXJSAMPLE;
-#endif
-      outptr += RGB_PIXELSIZE;
-    }
-  }
-}
-
-
-/*
- * Convert RGB to extended RGB: just swap the order of source pixels
- */
-
-INLINE
-LOCAL(void)
-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;
-  register JDIMENSION col;
-  JDIMENSION num_cols = cinfo->output_width;
-
-  while (--num_rows >= 0) {
-    inptr0 = input_buf[0][input_row];
-    inptr1 = input_buf[1][input_row];
-    inptr2 = input_buf[2][input_row];
-    input_row++;
-    outptr = *output_buf++;
-    for (col = 0; col < num_cols; col++) {
-      outptr[RGB_RED] = inptr0[col];
-      outptr[RGB_GREEN] = inptr1[col];
-      outptr[RGB_BLUE] = inptr2[col];
-      /* Set unused byte to _MAXJSAMPLE so it can be interpreted as an */
-      /* opaque alpha channel value */
-#ifdef RGB_ALPHA
-      outptr[RGB_ALPHA] = _MAXJSAMPLE;
-#endif
-      outptr += RGB_PIXELSIZE;
-    }
-  }
-}
@@ -1,925 +0,0 @@
-/*
- * jdcolor.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1991-1997, Thomas G. Lane.
- * Modified 2011 by Guido Vollbeding.
- * libjpeg-turbo Modifications:
- * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
- * Copyright (C) 2009, 2011-2012, 2014-2015, 2022, D. R. Commander.
- * Copyright (C) 2013, Linaro Limited.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains output colorspace conversion routines.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jsimd.h"
-#include "jsamplecomp.h"
-
-
-#if BITS_IN_JSAMPLE != 16 || defined(D_LOSSLESS_SUPPORTED)
-
-/* Private subobject */
-
-typedef struct {
-  struct jpeg_color_deconverter pub; /* public fields */
-
-#if BITS_IN_JSAMPLE != 16
-  /* 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 */
-
-  /* Private state for RGB->Y conversion */
-  JLONG *rgb_y_tab;             /* => table for RGB to Y conversion */
-#endif
-} my_color_deconverter;
-
-typedef my_color_deconverter *my_cconvert_ptr;
-
-
-/**************** YCbCr -> RGB conversion: most common case **************/
-/****************   RGB -> Y   conversion: less common case **************/
-
-/*
- * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
- * normalized to the range 0.._MAXJSAMPLE rather than -0.5 .. 0.5.
- * The conversion equations to be implemented are therefore
- *
- *      R = Y                + 1.40200 * Cr
- *      G = Y - 0.34414 * Cb - 0.71414 * Cr
- *      B = Y + 1.77200 * Cb
- *
- *      Y = 0.29900 * R + 0.58700 * G + 0.11400 * B
- *
- * where Cb and Cr represent the incoming values less _CENTERJSAMPLE.
- * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.)
- *
- * To avoid floating-point arithmetic, we represent the fractional constants
- * as integers scaled up by 2^16 (about 4 digits precision); we have to divide
- * the products by 2^16, with appropriate rounding, to get the correct answer.
- * Notice that Y, being an integral input, does not contribute any fraction
- * so it need not participate in the rounding.
- *
- * For even more speed, we avoid doing any multiplications in the inner loop
- * by precalculating the constants times Cb and Cr for all possible values.
- * For 8-bit samples this is very reasonable (only 256 entries per table);
- * for 12-bit samples it is still acceptable.  It's not very reasonable for
- * 16-bit samples, but if you want lossless storage you shouldn't be changing
- * colorspace anyway.
- * The Cr=>R and Cb=>B values can be rounded to integers in advance; the
- * values for the G calculation are left scaled up, since we must add them
- * together before rounding.
- */
-
-#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))
-
-/* 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
- * use a single table base address, which can be held in a register in the
- * inner loops on many machines (more than can hold all three addresses,
- * anyway).
- */
-
-#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))
-
-
-/* Include inline routines for colorspace extensions */
-
-#include "jdcolext.c"
-#undef RGB_RED
-#undef RGB_GREEN
-#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
-#include "jdcolext.c"
-#undef RGB_RED
-#undef RGB_GREEN
-#undef RGB_BLUE
-#undef RGB_PIXELSIZE
-#undef ycc_rgb_convert_internal
-#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
-#include "jdcolext.c"
-#undef RGB_RED
-#undef RGB_GREEN
-#undef RGB_BLUE
-#undef RGB_ALPHA
-#undef RGB_PIXELSIZE
-#undef ycc_rgb_convert_internal
-#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
-#include "jdcolext.c"
-#undef RGB_RED
-#undef RGB_GREEN
-#undef RGB_BLUE
-#undef RGB_PIXELSIZE
-#undef ycc_rgb_convert_internal
-#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
-#include "jdcolext.c"
-#undef RGB_RED
-#undef RGB_GREEN
-#undef RGB_BLUE
-#undef RGB_ALPHA
-#undef RGB_PIXELSIZE
-#undef ycc_rgb_convert_internal
-#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
-#include "jdcolext.c"
-#undef RGB_RED
-#undef RGB_GREEN
-#undef RGB_BLUE
-#undef RGB_ALPHA
-#undef RGB_PIXELSIZE
-#undef ycc_rgb_convert_internal
-#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
-#include "jdcolext.c"
-#undef RGB_RED
-#undef RGB_GREEN
-#undef RGB_BLUE
-#undef RGB_ALPHA
-#undef RGB_PIXELSIZE
-#undef ycc_rgb_convert_internal
-#undef gray_rgb_convert_internal
-#undef rgb_rgb_convert_internal
-
-
-/*
- * Initialize tables for YCC->RGB colorspace conversion.
- */
-
-LOCAL(void)
-build_ycc_rgb_table(j_decompress_ptr cinfo)
-{
-#if BITS_IN_JSAMPLE != 16
-  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));
-  cconvert->Cb_b_tab = (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));
-  cconvert->Cb_g_tab = (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 */
-    /* The Cb or Cr value we are thinking of is x = i - _CENTERJSAMPLE */
-    /* Cr=>R value is nearest int to 1.40200 * x */
-    cconvert->Cr_r_tab[i] = (int)
-                    RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
-    /* Cb=>B value is nearest int to 1.77200 * x */
-    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;
-    /* 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;
-  }
-#else
-  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-#endif
-}
-
-
-/*
- * Convert some rows of samples to the output colorspace.
- */
-
-METHODDEF(void)
-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;
-  }
-}
-
-
-/**************** Cases other than YCbCr -> RGB **************/
-
-
-/*
- * Initialize for RGB->grayscale colorspace conversion.
- */
-
-LOCAL(void)
-build_rgb_y_table(j_decompress_ptr cinfo)
-{
-#if BITS_IN_JSAMPLE != 16
-  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,
-                                (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;
-  }
-#else
-  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-#endif
-}
-
-
-/*
- * Convert RGB to grayscale.
- */
-
-METHODDEF(void)
-rgb_gray_convert(j_decompress_ptr cinfo, _JSAMPIMAGE input_buf,
-                 JDIMENSION input_row, _JSAMPARRAY output_buf, int num_rows)
-{
-#if BITS_IN_JSAMPLE != 16
-  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
-  register int r, g, b;
-  register JLONG *ctab = cconvert->rgb_y_tab;
-  register _JSAMPROW outptr;
-  register _JSAMPROW inptr0, inptr1, inptr2;
-  register JDIMENSION col;
-  JDIMENSION num_cols = cinfo->output_width;
-
-  while (--num_rows >= 0) {
-    inptr0 = input_buf[0][input_row];
-    inptr1 = input_buf[1][input_row];
-    inptr2 = input_buf[2][input_row];
-    input_row++;
-    outptr = *output_buf++;
-    for (col = 0; col < num_cols; col++) {
-      r = inptr0[col];
-      g = inptr1[col];
-      b = inptr2[col];
-      /* Y */
-      outptr[col] = (_JSAMPLE)((ctab[r + R_Y_OFF] + ctab[g + G_Y_OFF] +
-                                ctab[b + B_Y_OFF]) >> SCALEBITS);
-    }
-  }
-#else
-  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-#endif
-}
-
-
-/*
- * Color conversion for no colorspace change: just copy the data,
- * converting from separate-planes to interleaved representation.
- */
-
-METHODDEF(void)
-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;
-  register int num_components = cinfo->num_components;
-  JDIMENSION num_cols = cinfo->output_width;
-  int ci;
-
-  if (num_components == 3) {
-    while (--num_rows >= 0) {
-      inptr0 = input_buf[0][input_row];
-      inptr1 = input_buf[1][input_row];
-      inptr2 = input_buf[2][input_row];
-      input_row++;
-      outptr = *output_buf++;
-      for (col = 0; col < num_cols; col++) {
-        *outptr++ = inptr0[col];
-        *outptr++ = inptr1[col];
-        *outptr++ = inptr2[col];
-      }
-    }
-  } else if (num_components == 4) {
-    while (--num_rows >= 0) {
-      inptr0 = input_buf[0][input_row];
-      inptr1 = input_buf[1][input_row];
-      inptr2 = input_buf[2][input_row];
-      inptr3 = input_buf[3][input_row];
-      input_row++;
-      outptr = *output_buf++;
-      for (col = 0; col < num_cols; col++) {
-        *outptr++ = inptr0[col];
-        *outptr++ = inptr1[col];
-        *outptr++ = inptr2[col];
-        *outptr++ = inptr3[col];
-      }
-    }
-  } else {
-    while (--num_rows >= 0) {
-      for (ci = 0; ci < num_components; ci++) {
-        inptr = input_buf[ci][input_row];
-        outptr = *output_buf;
-        for (col = 0; col < num_cols; col++) {
-          outptr[ci] = inptr[col];
-          outptr += num_components;
-        }
-      }
-      output_buf++;
-      input_row++;
-    }
-  }
-}
-
-
-/*
- * Color conversion for grayscale: just copy the data.
- * This also works for YCbCr -> grayscale conversion, in which
- * we just copy the Y (luminance) component and ignore chrominance.
- */
-
-METHODDEF(void)
-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);
-}
-
-
-/*
- * Convert grayscale to RGB
- */
-
-METHODDEF(void)
-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;
-  }
-}
-
-
-/*
- * Convert plain RGB to extended RGB
- */
-
-METHODDEF(void)
-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;
-  }
-}
-
-
-/*
- * Adobe-style YCCK->CMYK conversion.
- * We convert YCbCr to R=1-C, G=1-M, and B=1-Y using the same
- * conversion as above, while passing K (black) unchanged.
- * We assume build_ycc_rgb_table has been called.
- */
-
-METHODDEF(void)
-ycck_cmyk_convert(j_decompress_ptr cinfo, _JSAMPIMAGE input_buf,
-                  JDIMENSION input_row, _JSAMPARRAY output_buf, int num_rows)
-{
-#if BITS_IN_JSAMPLE != 16
-  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
-  register int y, cb, cr;
-  register _JSAMPROW outptr;
-  register _JSAMPROW inptr0, inptr1, inptr2, inptr3;
-  register JDIMENSION col;
-  JDIMENSION num_cols = cinfo->output_width;
-  /* copy these pointers into registers if possible */
-  register _JSAMPLE *range_limit = (_JSAMPLE *)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) {
-    inptr0 = input_buf[0][input_row];
-    inptr1 = input_buf[1][input_row];
-    inptr2 = input_buf[2][input_row];
-    inptr3 = input_buf[3][input_row];
-    input_row++;
-    outptr = *output_buf++;
-    for (col = 0; col < num_cols; col++) {
-      y  = inptr0[col];
-      cb = inptr1[col];
-      cr = 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],
-                                                 SCALEBITS)))];
-      outptr[2] = range_limit[_MAXJSAMPLE - (y + Cbbtab[cb])];  /* blue */
-      /* K passes through unchanged */
-      outptr[3] = inptr3[col];
-      outptr += 4;
-    }
-  }
-#else
-  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-#endif
-}
-
-
-/*
- * 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_TWO_PIXELS_LE(l, r)    ((r << 16) | l)
-#define PACK_TWO_PIXELS_BE(l, r)    ((l << 16) | r)
-
-#define PACK_NEED_ALIGNMENT(ptr)    (((size_t)(ptr)) & 3)
-
-#define WRITE_TWO_ALIGNED_PIXELS(addr, pixels)  ((*(int *)(addr)) = pixels)
-
-#define DITHER_565_R(r, dither)  ((r) + ((dither) & 0xFF))
-#define DITHER_565_G(g, dither)  ((g) + (((dither) & 0xFF) >> 1))
-#define DITHER_565_B(b, dither)  ((b) + ((dither) & 0xFF))
-
-
-/* Declarations for ordered dithering
- *
- * We use a 4x4 ordered dither array packed into 32 bits.  This array is
- * sufficient for dithering RGB888 to RGB565.
- */
-
-#define DITHER_MASK       0x3
-#define DITHER_ROTATE(x)  ((((x) & 0xFF) << 24) | (((x) >> 8) & 0x00FFFFFF))
-static const JLONG dither_matrix[4] = {
-  0x0008020A,
-  0x0C040E06,
-  0x030B0109,
-  0x0F070D05
-};
-
-
-static INLINE boolean is_big_endian(void)
-{
-  int test_value = 1;
-  if (*(char *)&test_value != 1)
-    return TRUE;
-  return FALSE;
-}
-
-
-/* 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
-#include "jdcol565.c"
-#undef PACK_SHORT_565
-#undef PACK_TWO_PIXELS
-#undef ycc_rgb565_convert_internal
-#undef ycc_rgb565D_convert_internal
-#undef rgb_rgb565_convert_internal
-#undef rgb_rgb565D_convert_internal
-#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
-#include "jdcol565.c"
-#undef PACK_SHORT_565
-#undef PACK_TWO_PIXELS
-#undef ycc_rgb565_convert_internal
-#undef ycc_rgb565D_convert_internal
-#undef rgb_rgb565_convert_internal
-#undef rgb_rgb565D_convert_internal
-#undef gray_rgb565_convert_internal
-#undef gray_rgb565D_convert_internal
-
-
-METHODDEF(void)
-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);
-  else
-    ycc_rgb565_convert_le(cinfo, input_buf, input_row, output_buf, num_rows);
-}
-
-
-METHODDEF(void)
-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);
-  else
-    ycc_rgb565D_convert_le(cinfo, input_buf, input_row, output_buf, num_rows);
-}
-
-
-METHODDEF(void)
-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);
-  else
-    rgb_rgb565_convert_le(cinfo, input_buf, input_row, output_buf, num_rows);
-}
-
-
-METHODDEF(void)
-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);
-  else
-    rgb_rgb565D_convert_le(cinfo, input_buf, input_row, output_buf, num_rows);
-}
-
-
-METHODDEF(void)
-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);
-  else
-    gray_rgb565_convert_le(cinfo, input_buf, input_row, output_buf, num_rows);
-}
-
-
-METHODDEF(void)
-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);
-  else
-    gray_rgb565D_convert_le(cinfo, input_buf, input_row, output_buf, num_rows);
-}
-
-
-/*
- * Empty method for start_pass.
- */
-
-METHODDEF(void)
-start_pass_dcolor(j_decompress_ptr cinfo)
-{
-  /* no work needed */
-}
-
-
-/*
- * Module initialization routine for output colorspace conversion.
- */
-
-GLOBAL(void)
-_jinit_color_deconverter(j_decompress_ptr cinfo)
-{
-  my_cconvert_ptr cconvert;
-  int ci;
-
-  if (cinfo->data_precision != BITS_IN_JSAMPLE)
-    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-
-  cconvert = (my_cconvert_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                sizeof(my_color_deconverter));
-  cinfo->cconvert = (struct jpeg_color_deconverter *)cconvert;
-  cconvert->pub.start_pass = start_pass_dcolor;
-
-  /* Make sure num_components agrees with jpeg_color_space */
-  switch (cinfo->jpeg_color_space) {
-  case JCS_GRAYSCALE:
-    if (cinfo->num_components != 1)
-      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
-    break;
-
-  case JCS_RGB:
-  case JCS_YCbCr:
-    if (cinfo->num_components != 3)
-      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
-    break;
-
-  case JCS_CMYK:
-  case JCS_YCCK:
-    if (cinfo->num_components != 4)
-      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
-    break;
-
-  default:                      /* JCS_UNKNOWN can be anything */
-    if (cinfo->num_components < 1)
-      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
-    break;
-  }
-
-  /* Set out_color_components and conversion method based on requested space.
-   * Also clear the component_needed flags for any unused components,
-   * so that earlier pipeline stages can avoid useless computation.
-   * NOTE: We do not allow any lossy color conversion algorithms in lossless
-   * mode.
-   */
-
-  switch (cinfo->out_color_space) {
-  case JCS_GRAYSCALE:
-    if (cinfo->master->lossless &&
-        cinfo->jpeg_color_space != cinfo->out_color_space)
-      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    cinfo->out_color_components = 1;
-    if (cinfo->jpeg_color_space == JCS_GRAYSCALE ||
-        cinfo->jpeg_color_space == JCS_YCbCr) {
-      cconvert->pub._color_convert = grayscale_convert;
-      /* For color->grayscale conversion, only the Y (0) component is needed */
-      for (ci = 1; ci < cinfo->num_components; ci++)
-        cinfo->comp_info[ci].component_needed = FALSE;
-    } else if (cinfo->jpeg_color_space == JCS_RGB) {
-      cconvert->pub._color_convert = rgb_gray_convert;
-      build_rgb_y_table(cinfo);
-    } else
-      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    break;
-
-  case JCS_RGB:
-  case JCS_EXT_RGB:
-  case JCS_EXT_RGBX:
-  case JCS_EXT_BGR:
-  case JCS_EXT_BGRX:
-  case JCS_EXT_XBGR:
-  case JCS_EXT_XRGB:
-  case JCS_EXT_RGBA:
-  case JCS_EXT_BGRA:
-  case JCS_EXT_ABGR:
-  case JCS_EXT_ARGB:
-    if (cinfo->master->lossless && cinfo->jpeg_color_space != JCS_RGB)
-      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    cinfo->out_color_components = rgb_pixelsize[cinfo->out_color_space];
-    if (cinfo->jpeg_color_space == JCS_YCbCr) {
-#ifdef WITH_SIMD
-      if (jsimd_can_ycc_rgb())
-        cconvert->pub._color_convert = jsimd_ycc_rgb_convert;
-      else
-#endif
-      {
-        cconvert->pub._color_convert = ycc_rgb_convert;
-        build_ycc_rgb_table(cinfo);
-      }
-    } else if (cinfo->jpeg_color_space == JCS_GRAYSCALE) {
-      cconvert->pub._color_convert = gray_rgb_convert;
-    } else if (cinfo->jpeg_color_space == JCS_RGB) {
-      if (rgb_red[cinfo->out_color_space] == 0 &&
-          rgb_green[cinfo->out_color_space] == 1 &&
-          rgb_blue[cinfo->out_color_space] == 2 &&
-          rgb_pixelsize[cinfo->out_color_space] == 3)
-        cconvert->pub._color_convert = null_convert;
-      else
-        cconvert->pub._color_convert = rgb_rgb_convert;
-    } else
-      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    break;
-
-  case JCS_RGB565:
-    if (cinfo->master->lossless)
-      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    cinfo->out_color_components = 3;
-    if (cinfo->dither_mode == JDITHER_NONE) {
-      if (cinfo->jpeg_color_space == JCS_YCbCr) {
-#ifdef WITH_SIMD
-        if (jsimd_can_ycc_rgb565())
-          cconvert->pub._color_convert = jsimd_ycc_rgb565_convert;
-        else
-#endif
-        {
-          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;
-      } else if (cinfo->jpeg_color_space == JCS_RGB) {
-        cconvert->pub._color_convert = rgb_rgb565_convert;
-      } else
-        ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    } else {
-      /* only ordered dithering is supported */
-      if (cinfo->jpeg_color_space == JCS_YCbCr) {
-        cconvert->pub._color_convert = ycc_rgb565D_convert;
-        build_ycc_rgb_table(cinfo);
-      } else if (cinfo->jpeg_color_space == JCS_GRAYSCALE) {
-        cconvert->pub._color_convert = gray_rgb565D_convert;
-      } else if (cinfo->jpeg_color_space == JCS_RGB) {
-        cconvert->pub._color_convert = rgb_rgb565D_convert;
-      } else
-        ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    }
-    break;
-
-  case JCS_CMYK:
-    if (cinfo->master->lossless &&
-        cinfo->jpeg_color_space != cinfo->out_color_space)
-      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    cinfo->out_color_components = 4;
-    if (cinfo->jpeg_color_space == JCS_YCCK) {
-      cconvert->pub._color_convert = ycck_cmyk_convert;
-      build_ycc_rgb_table(cinfo);
-    } else if (cinfo->jpeg_color_space == JCS_CMYK) {
-      cconvert->pub._color_convert = null_convert;
-    } else
-      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    break;
-
-  default:
-    /* Permit null conversion to same output space */
-    if (cinfo->out_color_space == cinfo->jpeg_color_space) {
-      cinfo->out_color_components = cinfo->num_components;
-      cconvert->pub._color_convert = null_convert;
-    } else                      /* unsupported non-null conversion */
-      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    break;
-  }
-
-  if (cinfo->quantize_colors)
-    cinfo->output_components = 1; /* single colormapped output component */
-  else
-    cinfo->output_components = cinfo->out_color_components;
-}
-
-#endif /* BITS_IN_JSAMPLE != 16 || defined(D_LOSSLESS_SUPPORTED) */
@@ -1,221 +0,0 @@
-/*
- * jdct.h
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1994-1996, Thomas G. Lane.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2015, 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This include file contains common declarations for the forward and
- * inverse DCT modules.  These declarations are private to the DCT managers
- * (jcdctmgr.c, jddctmgr.c) and the individual DCT algorithms.
- * The individual DCT algorithms are kept in separate files to ease
- * machine-dependent tuning (e.g., assembly coding).
- */
-
-#include "jsamplecomp.h"
-
-
-/*
- * A forward DCT routine is given a pointer to a work area of type DCTELEM[];
- * the DCT is to be performed in-place in that buffer.  Type DCTELEM is int
- * for 8-bit samples, JLONG for 12-bit samples.  (NOTE: Floating-point DCT
- * implementations use an array of type FAST_FLOAT, instead.)
- * The DCT inputs are expected to be signed (range +-_CENTERJSAMPLE).
- * The DCT outputs are returned scaled up by a factor of 8; they therefore
- * have a range of +-8K for 8-bit data, +-128K for 12-bit data.  This
- * convention improves accuracy in integer implementations and saves some
- * work in floating-point ones.
- * Quantization of the output coefficients is done by jcdctmgr.c. This
- * step requires an unsigned type and also one with twice the bits.
- */
-
-#if BITS_IN_JSAMPLE == 8
-#ifndef WITH_SIMD
-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 unsigned short UDCTELEM;
-typedef unsigned int UDCTELEM2;
-#endif
-#else
-typedef JLONG DCTELEM;          /* must have 32 bits */
-typedef unsigned long long UDCTELEM2;
-#endif
-
-
-/*
- * An inverse DCT routine is given a pointer to the input JBLOCK and a pointer
- * to an output sample array.  The routine must dequantize the input data as
- * well as perform the IDCT; for dequantization, it uses the multiplier table
- * pointed to by compptr->dct_table.  The output data is to be placed into the
- * sample array starting at a specified column.  (Any row offset needed will
- * be applied to the array pointer before it is passed to the IDCT code.)
- * Note that the number of samples emitted by the IDCT routine is
- * DCT_scaled_size * DCT_scaled_size.
- */
-
-/* typedef inverse_DCT_method_ptr is declared in jpegint.h */
-
-/*
- * 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 */
-#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 */
-#else
-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 */
-
-
-/*
- * Each IDCT routine is responsible for range-limiting its results and
- * converting them to unsigned form (0.._MAXJSAMPLE).  The raw outputs could
- * be quite far out of range if the input data is corrupt, so a bulletproof
- * range-limiting step is required.  We use a mask-and-table-lookup method
- * to do the combined operations quickly.  See the comments with
- * prepare_range_limit_table (in jdmaster.c) for more info.
- */
-
-#define IDCT_range_limit(cinfo) \
-  ((_JSAMPLE *)((cinfo)->sample_range_limit) + _CENTERJSAMPLE)
-
-#define RANGE_MASK  (_MAXJSAMPLE * 4 + 3) /* 2 bits wider than legal samples */
-
-
-/* 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_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);
-
-
-/*
- * Macros for handling fixed-point arithmetic; these are used by many
- * but not all of the DCT/IDCT modules.
- *
- * All values are expected to be of type JLONG.
- * Fractional constants are scaled left by CONST_BITS bits.
- * CONST_BITS is defined within each module using these macros,
- * and may differ from one module to the next.
- */
-
-#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))
-
-/* 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)
-
-/* 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
- * 16 bits wide, so that a 16x16->32 bit multiply can be used instead of a
- * full 32x32 multiply.  This provides a useful speedup on many machines.
- * Unfortunately there is no way to specify a 16x16->32 multiply portably
- * in C, but some C compilers will do the right thing if you provide the
- * correct combination of casts.
- */
-
-#ifdef SHORTxSHORT_32           /* may work if 'int' is 32 bits */
-#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)))
-#endif
-
-#ifndef MULTIPLY16C16           /* default definition */
-#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)))
-#endif
-
-#ifndef MULTIPLY16V16           /* default definition */
-#define MULTIPLY16V16(var1, var2)  ((var1) * (var2))
-#endif
@@ -1,365 +0,0 @@
-/*
- * jddctmgr.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1994-1996, Thomas G. Lane.
- * Modified 2002-2010 by Guido Vollbeding.
- * libjpeg-turbo Modifications:
- * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
- * Copyright (C) 2010, 2015, 2022, D. R. Commander.
- * Copyright (C) 2013, MIPS Technologies, Inc., California.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains the inverse-DCT management logic.
- * This code selects a particular IDCT implementation to be used,
- * and it performs related housekeeping chores.  No code in this file
- * is executed per IDCT step, only during output pass setup.
- *
- * Note that the IDCT routines are responsible for performing coefficient
- * dequantization as well as the IDCT proper.  This module sets up the
- * dequantization multiplier table needed by the IDCT routine.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jdct.h"               /* Private declarations for DCT subsystem */
-#include "jsimddct.h"
-#include "jpegapicomp.h"
-
-
-/*
- * The decompressor input side (jdinput.c) saves away the appropriate
- * quantization table for each component at the start of the first scan
- * involving that component.  (This is necessary in order to correctly
- * decode files that reuse Q-table slots.)
- * When we are ready to make an output pass, the saved Q-table is converted
- * to a multiplier table that will actually be used by the IDCT routine.
- * The multiplier table contents are IDCT-method-dependent.  To support
- * application changes in IDCT method between scans, we can remake the
- * multiplier tables if necessary.
- * In buffered-image mode, the first output pass may occur before any data
- * has been seen for some components, and thus before their Q-tables have
- * been saved away.  To handle this case, multiplier tables are preset
- * to zeroes; the result of the IDCT will be a neutral gray level.
- */
-
-
-/* Private subobject for this module */
-
-typedef struct {
-  struct jpeg_inverse_dct pub;  /* public fields */
-
-  /* This array contains the IDCT method code that each multiplier table
-   * is currently set up for, or -1 if it's not yet set up.
-   * The actual multiplier tables are pointed to by dct_table in the
-   * per-component comp_info structures.
-   */
-  int cur_method[MAX_COMPONENTS];
-} my_idct_controller;
-
-typedef my_idct_controller *my_idct_ptr;
-
-
-/* Allocated multiplier tables: big enough for any supported variant */
-
-typedef union {
-  ISLOW_MULT_TYPE islow_array[DCTSIZE2];
-#ifdef DCT_IFAST_SUPPORTED
-  IFAST_MULT_TYPE ifast_array[DCTSIZE2];
-#endif
-#ifdef DCT_FLOAT_SUPPORTED
-  FLOAT_MULT_TYPE float_array[DCTSIZE2];
-#endif
-} multiplier_table;
-
-
-/* The current scaled-IDCT routines require ISLOW-style multiplier tables,
- * so be sure to compile that code if either ISLOW or SCALING is requested.
- */
-#ifdef DCT_ISLOW_SUPPORTED
-#define PROVIDE_ISLOW_TABLES
-#else
-#ifdef IDCT_SCALING_SUPPORTED
-#define PROVIDE_ISLOW_TABLES
-#endif
-#endif
-
-
-/*
- * Prepare for an output pass.
- * Here we select the proper IDCT routine for each component and build
- * a matching multiplier table.
- */
-
-METHODDEF(void)
-start_pass(j_decompress_ptr cinfo)
-{
-  my_idct_ptr idct = (my_idct_ptr)cinfo->idct;
-  int ci, i;
-  jpeg_component_info *compptr;
-  int method = 0;
-  _inverse_DCT_method_ptr method_ptr = NULL;
-  JQUANT_TBL *qtbl;
-
-  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-       ci++, compptr++) {
-    /* Select the proper IDCT routine for this component's scaling */
-    switch (compptr->_DCT_scaled_size) {
-#ifdef IDCT_SCALING_SUPPORTED
-    case 1:
-      method_ptr = _jpeg_idct_1x1;
-      method = JDCT_ISLOW;      /* jidctred uses islow-style table */
-      break;
-    case 2:
-#ifdef WITH_SIMD
-      if (jsimd_can_idct_2x2())
-        method_ptr = jsimd_idct_2x2;
-      else
-#endif
-        method_ptr = _jpeg_idct_2x2;
-      method = JDCT_ISLOW;      /* jidctred uses islow-style table */
-      break;
-    case 3:
-      method_ptr = _jpeg_idct_3x3;
-      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
-      break;
-    case 4:
-#ifdef WITH_SIMD
-      if (jsimd_can_idct_4x4())
-        method_ptr = jsimd_idct_4x4;
-      else
-#endif
-        method_ptr = _jpeg_idct_4x4;
-      method = JDCT_ISLOW;      /* jidctred uses islow-style table */
-      break;
-    case 5:
-      method_ptr = _jpeg_idct_5x5;
-      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
-      break;
-    case 6:
-#if defined(WITH_SIMD) && defined(__mips__)
-      if (jsimd_can_idct_6x6())
-        method_ptr = jsimd_idct_6x6;
-      else
-#endif
-      method_ptr = _jpeg_idct_6x6;
-      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
-      break;
-    case 7:
-      method_ptr = _jpeg_idct_7x7;
-      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
-      break;
-#endif
-    case DCTSIZE:
-      switch (cinfo->dct_method) {
-#ifdef DCT_ISLOW_SUPPORTED
-      case JDCT_ISLOW:
-#ifdef WITH_SIMD
-        if (jsimd_can_idct_islow())
-          method_ptr = jsimd_idct_islow;
-        else
-#endif
-          method_ptr = _jpeg_idct_islow;
-        method = JDCT_ISLOW;
-        break;
-#endif
-#ifdef DCT_IFAST_SUPPORTED
-      case JDCT_IFAST:
-#ifdef WITH_SIMD
-        if (jsimd_can_idct_ifast())
-          method_ptr = jsimd_idct_ifast;
-        else
-#endif
-          method_ptr = _jpeg_idct_ifast;
-        method = JDCT_IFAST;
-        break;
-#endif
-#ifdef DCT_FLOAT_SUPPORTED
-      case JDCT_FLOAT:
-#ifdef WITH_SIMD
-        if (jsimd_can_idct_float())
-          method_ptr = jsimd_idct_float;
-        else
-#endif
-          method_ptr = _jpeg_idct_float;
-        method = JDCT_FLOAT;
-        break;
-#endif
-      default:
-        ERREXIT(cinfo, JERR_NOT_COMPILED);
-        break;
-      }
-      break;
-#ifdef IDCT_SCALING_SUPPORTED
-    case 9:
-      method_ptr = _jpeg_idct_9x9;
-      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
-      break;
-    case 10:
-      method_ptr = _jpeg_idct_10x10;
-      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
-      break;
-    case 11:
-      method_ptr = _jpeg_idct_11x11;
-      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
-      break;
-    case 12:
-#if defined(WITH_SIMD) && defined(__mips__)
-      if (jsimd_can_idct_12x12())
-        method_ptr = jsimd_idct_12x12;
-      else
-#endif
-      method_ptr = _jpeg_idct_12x12;
-      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
-      break;
-    case 13:
-      method_ptr = _jpeg_idct_13x13;
-      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
-      break;
-    case 14:
-      method_ptr = _jpeg_idct_14x14;
-      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
-      break;
-    case 15:
-      method_ptr = _jpeg_idct_15x15;
-      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
-      break;
-    case 16:
-      method_ptr = _jpeg_idct_16x16;
-      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
-      break;
-#endif
-    default:
-      ERREXIT1(cinfo, JERR_BAD_DCTSIZE, compptr->_DCT_scaled_size);
-      break;
-    }
-    idct->pub._inverse_DCT[ci] = method_ptr;
-    /* Create multiplier table from quant table.
-     * However, we can skip this if the component is uninteresting
-     * or if we already built the table.  Also, if no quant table
-     * has yet been saved for the component, we leave the
-     * 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)
-      continue;
-    qtbl = compptr->quant_table;
-    if (qtbl == NULL)           /* happens if no data yet for component */
-      continue;
-    idct->cur_method[ci] = method;
-    switch (method) {
-#ifdef PROVIDE_ISLOW_TABLES
-    case JDCT_ISLOW:
-      {
-        /* 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;
-        for (i = 0; i < DCTSIZE2; i++) {
-          ismtbl[i] = (ISLOW_MULT_TYPE)qtbl->quantval[i];
-        }
-      }
-      break;
-#endif
-#ifdef DCT_IFAST_SUPPORTED
-    case JDCT_IFAST:
-      {
-        /* For AA&N IDCT method, multipliers are equal to quantization
-         * coefficients scaled by scalefactor[row]*scalefactor[col], where
-         *   scalefactor[0] = 1
-         *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
-         * 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
-        static const INT16 aanscales[DCTSIZE2] = {
-          /* precomputed values scaled up by 14 bits */
-          16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
-          22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
-          21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
-          19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
-          16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
-          12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
-           8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
-           4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
-        };
-        SHIFT_TEMPS
-
-        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);
-        }
-      }
-      break;
-#endif
-#ifdef DCT_FLOAT_SUPPORTED
-    case JDCT_FLOAT:
-      {
-        /* For float AA&N IDCT method, multipliers are equal to quantization
-         * coefficients scaled by scalefactor[row]*scalefactor[col], where
-         *   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;
-        int row, col;
-        static const double aanscalefactor[DCTSIZE] = {
-          1.0, 1.387039845, 1.306562965, 1.175875602,
-          1.0, 0.785694958, 0.541196100, 0.275899379
-        };
-
-        i = 0;
-        for (row = 0; row < DCTSIZE; row++) {
-          for (col = 0; col < DCTSIZE; col++) {
-            fmtbl[i] = (FLOAT_MULT_TYPE)
-              ((double)qtbl->quantval[i] *
-               aanscalefactor[row] * aanscalefactor[col]);
-            i++;
-          }
-        }
-      }
-      break;
-#endif
-    default:
-      ERREXIT(cinfo, JERR_NOT_COMPILED);
-      break;
-    }
-  }
-}
-
-
-/*
- * Initialize IDCT manager.
- */
-
-GLOBAL(void)
-_jinit_inverse_dct(j_decompress_ptr cinfo)
-{
-  my_idct_ptr idct;
-  int ci;
-  jpeg_component_info *compptr;
-
-  if (cinfo->data_precision != BITS_IN_JSAMPLE)
-    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-
-  idct = (my_idct_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                sizeof(my_idct_controller));
-  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,
-                                  sizeof(multiplier_table));
-    memset(compptr->dct_table, 0, sizeof(multiplier_table));
-    /* Mark multiplier table not yet set up for any method */
-    idct->cur_method[ci] = -1;
-  }
-}
@@ -1,403 +0,0 @@
-/*
- * jddiffct.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1994-1997, Thomas G. Lane.
- * Lossless JPEG Modifications:
- * Copyright (C) 1999, Ken Murchison.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains the [un]difference buffer controller for decompression.
- * This controller is the top level of the lossless JPEG decompressor proper.
- * The difference buffer lies between the entropy decoding and
- * prediction/undifferencing steps.  The undifference buffer lies between the
- * prediction/undifferencing and scaling steps.
- *
- * In buffered-image mode, this controller is the interface between
- * input-oriented processing and output-oriented processing.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jlossls.h"            /* Private declarations for lossless codec */
-
-
-#ifdef D_LOSSLESS_SUPPORTED
-
-/* Private buffer controller object */
-
-typedef struct {
-  struct jpeg_d_coef_controller pub; /* public fields */
-
-  /* These variables keep track of the current location of the input side. */
-  /* cinfo->input_iMCU_row is also used for this. */
-  JDIMENSION MCU_ctr;           /* counts MCUs processed in current row */
-  unsigned int restart_rows_to_go;      /* MCU rows left in this restart
-                                           interval */
-  unsigned int MCU_vert_offset;         /* counts MCU rows within iMCU row */
-  unsigned int MCU_rows_per_iMCU_row;   /* number of such rows needed */
-
-  /* The output side's location is represented by cinfo->output_iMCU_row. */
-
-  JDIFFARRAY diff_buf[MAX_COMPONENTS];  /* iMCU row of differences */
-  JDIFFARRAY undiff_buf[MAX_COMPONENTS]; /* iMCU row of undiff'd samples */
-
-#ifdef D_MULTISCAN_FILES_SUPPORTED
-  /* In multi-pass modes, we need a virtual sample array for each component. */
-  jvirt_sarray_ptr whole_image[MAX_COMPONENTS];
-#endif
-} my_diff_controller;
-
-typedef my_diff_controller *my_diff_ptr;
-
-/* Forward declarations */
-METHODDEF(int) decompress_data(j_decompress_ptr cinfo, _JSAMPIMAGE output_buf);
-#ifdef D_MULTISCAN_FILES_SUPPORTED
-METHODDEF(int) output_data(j_decompress_ptr cinfo, _JSAMPIMAGE output_buf);
-#endif
-
-
-LOCAL(void)
-start_iMCU_row(j_decompress_ptr cinfo)
-/* Reset within-iMCU-row counters for a new row (input side) */
-{
-  my_diff_ptr diff = (my_diff_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.
-   * But at the bottom of the image, process only what's left.
-   */
-  if (cinfo->comps_in_scan > 1) {
-    diff->MCU_rows_per_iMCU_row = 1;
-  } else {
-    if (cinfo->input_iMCU_row < (cinfo->total_iMCU_rows-1))
-      diff->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
-    else
-      diff->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
-  }
-
-  diff->MCU_ctr = 0;
-  diff->MCU_vert_offset = 0;
-}
-
-
-/*
- * Initialize for an input processing pass.
- */
-
-METHODDEF(void)
-start_input_pass(j_decompress_ptr cinfo)
-{
-  my_diff_ptr diff = (my_diff_ptr)cinfo->coef;
-
-  /* Because it is hitching a ride on the jpeg_inverse_dct struct,
-   * start_pass_lossless() will be called at the start of the output pass.
-   * This ensures that it will be called at the start of the input pass as
-   * well.
-   */
-  (*cinfo->idct->start_pass) (cinfo);
-
-  /* Check that the restart interval is an integer multiple of the number
-   * of MCUs in an MCU row.
-   */
-  if (cinfo->restart_interval % cinfo->MCUs_per_row != 0)
-    ERREXIT2(cinfo, JERR_BAD_RESTART,
-             cinfo->restart_interval, cinfo->MCUs_per_row);
-
-  /* Initialize restart counter */
-  diff->restart_rows_to_go = cinfo->restart_interval / cinfo->MCUs_per_row;
-
-  cinfo->input_iMCU_row = 0;
-  start_iMCU_row(cinfo);
-}
-
-
-/*
- * Check for a restart marker & resynchronize decoder, undifferencer.
- * Returns FALSE if must suspend.
- */
-
-METHODDEF(boolean)
-process_restart(j_decompress_ptr cinfo)
-{
-  my_diff_ptr diff = (my_diff_ptr)cinfo->coef;
-
-  if (!(*cinfo->entropy->process_restart) (cinfo))
-    return FALSE;
-
-  (*cinfo->idct->start_pass) (cinfo);
-
-  /* Reset restart counter */
-  diff->restart_rows_to_go = cinfo->restart_interval / cinfo->MCUs_per_row;
-
-  return TRUE;
-}
-
-
-/*
- * Initialize for an output processing pass.
- */
-
-METHODDEF(void)
-start_output_pass(j_decompress_ptr cinfo)
-{
-  cinfo->output_iMCU_row = 0;
-}
-
-
-/*
- * Decompress and return some data in the supplied buffer.
- * Always attempts to emit one fully interleaved MCU row ("iMCU" row).
- * Input and output must run in lockstep since we have only a one-MCU buffer.
- * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
- *
- * NB: output_buf contains a plane for each component in image,
- * which we index according to the component's SOF position.
- */
-
-METHODDEF(int)
-decompress_data(j_decompress_ptr cinfo, _JSAMPIMAGE output_buf)
-{
-  my_diff_ptr diff = (my_diff_ptr)cinfo->coef;
-  lossless_decomp_ptr losslessd = (lossless_decomp_ptr)cinfo->idct;
-  JDIMENSION MCU_col_num;       /* index of current MCU within row */
-  JDIMENSION MCU_count;         /* number of MCUs decoded */
-  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
-  int ci, compi, row, prev_row;
-  unsigned int yoffset;
-  jpeg_component_info *compptr;
-
-  /* Loop to process as much as one whole iMCU row */
-  for (yoffset = diff->MCU_vert_offset; yoffset < diff->MCU_rows_per_iMCU_row;
-       yoffset++) {
-
-    /* Process restart marker if needed; may have to suspend */
-    if (cinfo->restart_interval) {
-      if (diff->restart_rows_to_go == 0)
-        if (!process_restart(cinfo))
-          return JPEG_SUSPENDED;
-    }
-
-    MCU_col_num = diff->MCU_ctr;
-    /* Try to fetch an MCU row (or remaining portion of suspended MCU row). */
-    MCU_count =
-      (*cinfo->entropy->decode_mcus) (cinfo,
-                                      diff->diff_buf, yoffset, MCU_col_num,
-                                      cinfo->MCUs_per_row - MCU_col_num);
-    if (MCU_count != cinfo->MCUs_per_row - MCU_col_num) {
-      /* Suspension forced; update state counters and exit */
-      diff->MCU_vert_offset = yoffset;
-      diff->MCU_ctr += MCU_count;
-      return JPEG_SUSPENDED;
-    }
-
-    /* Account for restart interval (no-op if not using restarts) */
-    if (cinfo->restart_interval)
-      diff->restart_rows_to_go--;
-
-    /* Completed an MCU row, but perhaps not an iMCU row */
-    diff->MCU_ctr = 0;
-  }
-
-  /*
-   * Undifference and scale each scanline of the disassembled MCU row
-   * separately.  We do not process dummy samples at the end of a scanline
-   * or dummy rows at the end of the image.
-   */
-  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
-    compptr = cinfo->cur_comp_info[ci];
-    compi = compptr->component_index;
-    for (row = 0, prev_row = compptr->v_samp_factor - 1;
-         row < (cinfo->input_iMCU_row == last_iMCU_row ?
-                compptr->last_row_height : compptr->v_samp_factor);
-         prev_row = row, row++) {
-      (*losslessd->predict_undifference[compi])
-        (cinfo, compi, diff->diff_buf[compi][row],
-          diff->undiff_buf[compi][prev_row], diff->undiff_buf[compi][row],
-          compptr->width_in_blocks);
-      (*losslessd->scaler_scale) (cinfo, diff->undiff_buf[compi][row],
-                                  output_buf[compi][row],
-                                  compptr->width_in_blocks);
-    }
-  }
-
-  /* Completed the iMCU row, advance counters for next one.
-   *
-   * NB: output_data will increment output_iMCU_row.
-   * This counter is not needed for the single-pass case
-   * or the input side of the multi-pass case.
-   */
-  if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) {
-    start_iMCU_row(cinfo);
-    return JPEG_ROW_COMPLETED;
-  }
-  /* Completed the scan */
-  (*cinfo->inputctl->finish_input_pass) (cinfo);
-  return JPEG_SCAN_COMPLETED;
-}
-
-
-/*
- * Dummy consume-input routine for single-pass operation.
- */
-
-METHODDEF(int)
-dummy_consume_data(j_decompress_ptr cinfo)
-{
-  return JPEG_SUSPENDED;        /* Always indicate nothing was done */
-}
-
-
-#ifdef D_MULTISCAN_FILES_SUPPORTED
-
-/*
- * Consume input data and store it in the full-image sample buffer.
- * We read as much as one fully interleaved MCU row ("iMCU" row) per call,
- * ie, v_samp_factor rows for each component in the scan.
- * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
- */
-
-METHODDEF(int)
-consume_data(j_decompress_ptr cinfo)
-{
-  my_diff_ptr diff = (my_diff_ptr)cinfo->coef;
-  int ci, compi;
-  _JSAMPARRAY buffer[MAX_COMPS_IN_SCAN];
-  jpeg_component_info *compptr;
-
-  /* Align the virtual buffers for the components used in this scan. */
-  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
-    compptr = cinfo->cur_comp_info[ci];
-    compi = compptr->component_index;
-    buffer[compi] = (_JSAMPARRAY)(*cinfo->mem->access_virt_sarray)
-      ((j_common_ptr)cinfo, diff->whole_image[compi],
-       cinfo->input_iMCU_row * compptr->v_samp_factor,
-       (JDIMENSION)compptr->v_samp_factor, TRUE);
-  }
-
-  return decompress_data(cinfo, buffer);
-}
-
-
-/*
- * Output some data from the full-image sample buffer in the multi-pass case.
- * Always attempts to emit one fully interleaved MCU row ("iMCU" row).
- * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
- *
- * NB: output_buf contains a plane for each component in image.
- */
-
-METHODDEF(int)
-output_data(j_decompress_ptr cinfo, _JSAMPIMAGE output_buf)
-{
-  my_diff_ptr diff = (my_diff_ptr)cinfo->coef;
-  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
-  int ci, samp_rows, row;
-  _JSAMPARRAY buffer;
-  jpeg_component_info *compptr;
-
-  /* Force some input to be done if we are getting ahead of the input. */
-  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)
-      return JPEG_SUSPENDED;
-  }
-
-  /* OK, output from the virtual arrays. */
-  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-       ci++, compptr++) {
-    /* Align the virtual buffer for this component. */
-    buffer = (_JSAMPARRAY)(*cinfo->mem->access_virt_sarray)
-      ((j_common_ptr)cinfo, diff->whole_image[ci],
-       cinfo->output_iMCU_row * compptr->v_samp_factor,
-       (JDIMENSION)compptr->v_samp_factor, FALSE);
-
-    if (cinfo->output_iMCU_row < last_iMCU_row)
-      samp_rows = compptr->v_samp_factor;
-    else {
-      /* NB: can't use last_row_height here; it is input-side-dependent! */
-      samp_rows = (int)(compptr->height_in_blocks % compptr->v_samp_factor);
-      if (samp_rows == 0) samp_rows = compptr->v_samp_factor;
-    }
-
-    for (row = 0; row < samp_rows; row++) {
-      memcpy(output_buf[ci][row], buffer[row],
-             compptr->width_in_blocks * sizeof(_JSAMPLE));
-    }
-  }
-
-  if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows)
-    return JPEG_ROW_COMPLETED;
-  return JPEG_SCAN_COMPLETED;
-}
-
-#endif /* D_MULTISCAN_FILES_SUPPORTED */
-
-
-/*
- * Initialize difference buffer controller.
- */
-
-GLOBAL(void)
-_jinit_d_diff_controller(j_decompress_ptr cinfo, boolean need_full_buffer)
-{
-  my_diff_ptr diff;
-  int ci;
-  jpeg_component_info *compptr;
-
-  diff = (my_diff_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                sizeof(my_diff_controller));
-  cinfo->coef = (struct jpeg_d_coef_controller *)diff;
-  diff->pub.start_input_pass = start_input_pass;
-  diff->pub.start_output_pass = start_output_pass;
-
-  /* Create the [un]difference buffers. */
-  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-       ci++, compptr++) {
-    diff->diff_buf[ci] =
-      ALLOC_DARRAY(JPOOL_IMAGE,
-                   (JDIMENSION)jround_up((long)compptr->width_in_blocks,
-                                         (long)compptr->h_samp_factor),
-                   (JDIMENSION)compptr->v_samp_factor);
-    diff->undiff_buf[ci] =
-      ALLOC_DARRAY(JPOOL_IMAGE,
-                   (JDIMENSION)jround_up((long)compptr->width_in_blocks,
-                                         (long)compptr->h_samp_factor),
-                   (JDIMENSION)compptr->v_samp_factor);
-  }
-
-  if (need_full_buffer) {
-#ifdef D_MULTISCAN_FILES_SUPPORTED
-    /* Allocate a full-image virtual array for each component. */
-    int access_rows;
-
-    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-         ci++, compptr++) {
-      access_rows = compptr->v_samp_factor;
-      diff->whole_image[ci] = (*cinfo->mem->request_virt_sarray)
-        ((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)access_rows);
-    }
-    diff->pub.consume_data = consume_data;
-    diff->pub._decompress_data = output_data;
-#else
-    ERREXIT(cinfo, JERR_NOT_COMPILED);
-#endif
-  } else {
-    diff->pub.consume_data = dummy_consume_data;
-    diff->pub._decompress_data = decompress_data;
-    diff->whole_image[0] = NULL; /* flag for no virtual arrays */
-  }
-}
-
-#endif /* D_LOSSLESS_SUPPORTED */
@@ -1,836 +0,0 @@
-/*
- * jdhuff.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1991-1997, Thomas G. Lane.
- * Lossless JPEG Modifications:
- * Copyright (C) 1999, Ken Murchison.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2009-2011, 2016, 2018-2019, 2022, D. R. Commander.
- * Copyright (C) 2018, Matthias Räncker.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains Huffman entropy decoding routines.
- *
- * Much of the complexity here has to do with supporting input suspension.
- * If the data source module demands suspension, we want to be able to back
- * 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 jd*huff.c */
-#include "jpegapicomp.h"
-#include "jstdhuff.c"
-
-
-/*
- * Expanded entropy decoder object for Huffman decoding.
- *
- * The savable_state subrecord contains fields that change within an MCU,
- * but must not be updated permanently until we complete the MCU.
- */
-
-typedef struct {
-  int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
-} savable_state;
-
-typedef struct {
-  struct jpeg_entropy_decoder pub; /* public fields */
-
-  /* These fields are loaded into local variables at start of each MCU.
-   * In case of suspension, we exit WITHOUT updating them.
-   */
-  bitread_perm_state bitstate;  /* Bit buffer at start of MCU */
-  savable_state saved;          /* Other state at start of MCU */
-
-  /* These fields are NOT loaded into local working state. */
-  unsigned int restarts_to_go;  /* MCUs left in this restart interval */
-
-  /* Pointers to derived tables (these workspaces have image lifespan) */
-  d_derived_tbl *dc_derived_tbls[NUM_HUFF_TBLS];
-  d_derived_tbl *ac_derived_tbls[NUM_HUFF_TBLS];
-
-  /* Precalculated info set up by start_pass for use in decode_mcu: */
-
-  /* Pointers to derived tables to be used for each block within an MCU */
-  d_derived_tbl *dc_cur_tbls[D_MAX_BLOCKS_IN_MCU];
-  d_derived_tbl *ac_cur_tbls[D_MAX_BLOCKS_IN_MCU];
-  /* Whether we care about the DC and AC coefficient values for each block */
-  boolean dc_needed[D_MAX_BLOCKS_IN_MCU];
-  boolean ac_needed[D_MAX_BLOCKS_IN_MCU];
-} huff_entropy_decoder;
-
-typedef huff_entropy_decoder *huff_entropy_ptr;
-
-
-/*
- * Initialize for a Huffman-compressed scan.
- */
-
-METHODDEF(void)
-start_pass_huff_decoder(j_decompress_ptr cinfo)
-{
-  huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
-  int ci, blkn, dctbl, actbl;
-  d_derived_tbl **pdtbl;
-  jpeg_component_info *compptr;
-
-  /* Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG.
-   * 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 ||
-      cinfo->Ah != 0 || cinfo->Al != 0)
-    WARNMS(cinfo, JWRN_NOT_SEQUENTIAL);
-
-  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
-    compptr = cinfo->cur_comp_info[ci];
-    dctbl = compptr->dc_tbl_no;
-    actbl = compptr->ac_tbl_no;
-    /* Compute derived values for Huffman tables */
-    /* We may do this more than once for a table, but it's not expensive */
-    pdtbl = (d_derived_tbl **)(entropy->dc_derived_tbls) + dctbl;
-    jpeg_make_d_derived_tbl(cinfo, TRUE, dctbl, pdtbl);
-    pdtbl = (d_derived_tbl **)(entropy->ac_derived_tbls) + actbl;
-    jpeg_make_d_derived_tbl(cinfo, FALSE, actbl, pdtbl);
-    /* Initialize DC predictions to 0 */
-    entropy->saved.last_dc_val[ci] = 0;
-  }
-
-  /* Precalculate decoding info for each block in an MCU of this scan */
-  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
-    ci = cinfo->MCU_membership[blkn];
-    compptr = cinfo->cur_comp_info[ci];
-    /* Precalculate which table to use for each block */
-    entropy->dc_cur_tbls[blkn] = entropy->dc_derived_tbls[compptr->dc_tbl_no];
-    entropy->ac_cur_tbls[blkn] = entropy->ac_derived_tbls[compptr->ac_tbl_no];
-    /* Decide whether we really care about the coefficient values */
-    if (compptr->component_needed) {
-      entropy->dc_needed[blkn] = TRUE;
-      /* we don't need the ACs if producing a 1/8th-size image */
-      entropy->ac_needed[blkn] = (compptr->_DCT_scaled_size > 1);
-    } else {
-      entropy->dc_needed[blkn] = entropy->ac_needed[blkn] = FALSE;
-    }
-  }
-
-  /* Initialize bitread state variables */
-  entropy->bitstate.bits_left = 0;
-  entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */
-  entropy->pub.insufficient_data = FALSE;
-
-  /* Initialize restart counter */
-  entropy->restarts_to_go = cinfo->restart_interval;
-}
-
-
-/*
- * Compute the derived values for a Huffman table.
- * This routine also performs some validation checks on the table.
- *
- * Note this is also used by jdphuff.c and jdlhuff.c.
- */
-
-GLOBAL(void)
-jpeg_make_d_derived_tbl(j_decompress_ptr cinfo, boolean isDC, int tblno,
-                        d_derived_tbl **pdtbl)
-{
-  JHUFF_TBL *htbl;
-  d_derived_tbl *dtbl;
-  int p, i, l, si, numsymbols;
-  int lookbits, ctr;
-  char huffsize[257];
-  unsigned int huffcode[257];
-  unsigned int code;
-
-  /* Note that huffsize[] and huffcode[] are filled in code-length order,
-   * paralleling the order of the symbols themselves in htbl->huffval[].
-   */
-
-  /* Find the input Huffman table */
-  if (tblno < 0 || tblno >= NUM_HUFF_TBLS)
-    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
-  htbl =
-    isDC ? cinfo->dc_huff_tbl_ptrs[tblno] : cinfo->ac_huff_tbl_ptrs[tblno];
-  if (htbl == NULL)
-    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
-
-  /* Allocate a workspace if we haven't already done so. */
-  if (*pdtbl == NULL)
-    *pdtbl = (d_derived_tbl *)
-      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                  sizeof(d_derived_tbl));
-  dtbl = *pdtbl;
-  dtbl->pub = htbl;             /* fill in back link */
-
-  /* Figure C.1: make table of Huffman code length for each symbol */
-
-  p = 0;
-  for (l = 1; l <= 16; 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] = 0;
-  numsymbols = p;
-
-  /* Figure C.2: generate the codes themselves */
-  /* We also validate that the counts represent a legal Huffman code tree. */
-
-  code = 0;
-  si = huffsize[0];
-  p = 0;
-  while (huffsize[p]) {
-    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))
-      ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
-    code <<= 1;
-    si++;
-  }
-
-  /* Figure F.15: generate decoding tables for bit-sequential decoding */
-
-  p = 0;
-  for (l = 1; l <= 16; l++) {
-    if (htbl->bits[l]) {
-      /* 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];
-      p += htbl->bits[l];
-      dtbl->maxcode[l] = huffcode[p - 1]; /* maximum code of length l */
-    } else {
-      dtbl->maxcode[l] = -1;    /* -1 if no codes of this length */
-    }
-  }
-  dtbl->valoffset[17] = 0;
-  dtbl->maxcode[17] = 0xFFFFFL; /* ensures jpeg_huff_decode terminates */
-
-  /* Compute lookahead tables to speed up decoding.
-   * First we set all the table entries to 0, indicating "too long";
-   * then we iterate through the Huffman codes that are short enough and
-   * fill in all the entries that correspond to bit sequences starting
-   * with that code.
-   */
-
-  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++) {
-      /* 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--) {
-        dtbl->lookup[lookbits] = (l << HUFF_LOOKAHEAD) | htbl->huffval[p];
-        lookbits++;
-      }
-    }
-  }
-
-  /* Validate symbols as being reasonable.
-   * For AC tables, we make no check, but accept all byte values 0..255.
-   * For DC tables, we require the symbols to be in range 0..15 in lossy mode
-   * and 0..16 in lossless mode.  (Tighter bounds could be applied depending on
-   * the data depth and mode, but this is sufficient to ensure safe decoding.)
-   */
-  if (isDC) {
-    for (i = 0; i < numsymbols; i++) {
-      int sym = htbl->huffval[i];
-      if (sym < 0 || sym > (cinfo->master->lossless ? 16 : 15))
-        ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
-    }
-  }
-}
-
-
-/*
- * Out-of-line code for bit fetching (shared with jdphuff.c and jdlhuff.c).
- * See jdhuff.h for info about usage.
- * Note: current values of get_buffer and bits_left are passed as parameters,
- * but are returned in the corresponding fields of the state struct.
- *
- * On most machines MIN_GET_BITS should be 25 to allow the full 32-bit width
- * of get_buffer to be used.  (On machines with wider words, an even larger
- * buffer could be used.)  However, on some machines 32-bit shifts are
- * quite slow and take time proportional to the number of places shifted.
- * (This is true with most PC compilers, for instance.)  In this case it may
- * be a win to set MIN_GET_BITS to the minimum value of 15.  This reduces the
- * average shift distance at the cost of more calls to jpeg_fill_bit_buffer.
- */
-
-#ifdef SLOW_SHIFT_32
-#define MIN_GET_BITS  15        /* minimum allowable value */
-#else
-#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)
-/* Load up the bit buffer to a depth of at least nbits */
-{
-  /* Copy heavily used state fields into locals (hopefully registers) */
-  register const JOCTET *next_input_byte = state->next_input_byte;
-  register size_t bytes_in_buffer = state->bytes_in_buffer;
-  j_decompress_ptr cinfo = state->cinfo;
-
-  /* Attempt to load at least MIN_GET_BITS bits into get_buffer. */
-  /* (It is assumed that no request will be for more than that many bits.) */
-  /* We fail to do so only if we hit a marker or are forced to suspend. */
-
-  if (cinfo->unread_marker == 0) {      /* cannot advance past a marker */
-    while (bits_left < MIN_GET_BITS) {
-      register int c;
-
-      /* Attempt to read a byte */
-      if (bytes_in_buffer == 0) {
-        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++;
-
-      /* If it's 0xFF, check and discard stuffed zero byte */
-      if (c == 0xFF) {
-        /* Loop here to discard any padding FF's on terminating marker,
-         * so that we can save a valid unread_marker value.  NOTE: we will
-         * accept multiple FF's followed by a 0 as meaning a single FF data
-         * byte.  This data pattern is not valid according to the standard.
-         */
-        do {
-          if (bytes_in_buffer == 0) {
-            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++;
-        } while (c == 0xFF);
-
-        if (c == 0) {
-          /* Found FF/00, which represents an FF data byte */
-          c = 0xFF;
-        } else {
-          /* Oops, it's actually a marker indicating end of compressed data.
-           * Save the marker code for later use.
-           * Fine point: it might appear that we should save the marker into
-           * bitread working state, not straight into permanent state.  But
-           * once we have hit a marker, we cannot need to suspend within the
-           * current MCU, because we will read no more bytes from the data
-           * source.  So it is OK to update permanent state right away.
-           */
-          cinfo->unread_marker = c;
-          /* See if we need to insert some fake zero bits. */
-          goto no_more_bytes;
-        }
-      }
-
-      /* OK, load c into get_buffer */
-      get_buffer = (get_buffer << 8) | c;
-      bits_left += 8;
-    } /* end while */
-  } else {
-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.
-     */
-    if (nbits > bits_left) {
-      /* Uh-oh.  Report corrupted data to user and stuff zeroes into
-       * the data stream, so that we can produce some kind of image.
-       * We use a nonvolatile flag to ensure that only one warning message
-       * appears per data segment.
-       */
-      if (!cinfo->entropy->insufficient_data) {
-        WARNMS(cinfo, JWRN_HIT_MARKER);
-        cinfo->entropy->insufficient_data = TRUE;
-      }
-      /* Fill the buffer with zero bits */
-      get_buffer <<= MIN_GET_BITS - bits_left;
-      bits_left = MIN_GET_BITS;
-    }
-  }
-
-  /* Unload the local registers */
-  state->next_input_byte = next_input_byte;
-  state->bytes_in_buffer = bytes_in_buffer;
-  state->get_buffer = get_buffer;
-  state->bits_left = bits_left;
-
-  return TRUE;
-}
-
-
-/* Macro version of the above, which performs much better but does not
-   handle markers.  We have to hand off any blocks with markers to the
-   slower routines. */
-
-#define GET_BYTE { \
-  register int c0, c1; \
-  c0 = *buffer++; \
-  c1 = *buffer; \
-  /* Pre-execute most common case */ \
-  get_buffer = (get_buffer << 8) | c0; \
-  bits_left += 8; \
-  if (c0 == 0xFF) { \
-    /* Pre-execute case of FF/00, which represents an FF data byte */ \
-    buffer++; \
-    if (c1 != 0) { \
-      /* Oops, it's actually a marker indicating end of compressed data. */ \
-      cinfo->unread_marker = c1; \
-      /* Back out pre-execution and fill the buffer with zero bits */ \
-      buffer -= 2; \
-      get_buffer &= ~0xFF; \
-    } \
-  } \
-}
-
-#if SIZEOF_SIZE_T == 8 || defined(_WIN64) || (defined(__x86_64__) && defined(__ILP32__))
-
-/* Pre-fetch 48 bytes, because the holding register is 64-bit */
-#define FILL_BIT_BUFFER_FAST \
-  if (bits_left <= 16) { \
-    GET_BYTE GET_BYTE GET_BYTE GET_BYTE GET_BYTE GET_BYTE \
-  }
-
-#else
-
-/* Pre-fetch 16 bytes, because the holding register is 32-bit */
-#define FILL_BIT_BUFFER_FAST \
-  if (bits_left <= 16) { \
-    GET_BYTE GET_BYTE \
-  }
-
-#endif
-
-
-/*
- * Out-of-line code for Huffman code decoding.
- * See jdhuff.h for info about usage.
- */
-
-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)
-{
-  register int l = min_bits;
-  register JLONG code;
-
-  /* HUFF_DECODE has determined that the code is at least min_bits */
-  /* bits long, so fetch that many bits in one swoop. */
-
-  CHECK_BIT_BUFFER(*state, l, return -1);
-  code = GET_BITS(l);
-
-  /* Collect the rest of the Huffman code one bit at a time. */
-  /* This is per Figure F.16. */
-
-  while (code > htbl->maxcode[l]) {
-    code <<= 1;
-    CHECK_BIT_BUFFER(*state, 1, return -1);
-    code |= GET_BITS(1);
-    l++;
-  }
-
-  /* Unload the local registers */
-  state->get_buffer = get_buffer;
-  state->bits_left = bits_left;
-
-  /* With garbage input we may reach the sentinel value l = 17. */
-
-  if (l > 16) {
-    WARNMS(state->cinfo, JWRN_HUFF_BAD_CODE);
-    return 0;                   /* fake a zero as the safest result */
-  }
-
-  return htbl->pub->huffval[(int)(code + htbl->valoffset[l])];
-}
-
-
-/*
- * Figure F.12: extend sign bit.
- * On some machines, a shift and add will be faster than a table lookup.
- */
-
-#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)))
-
-#else
-
-#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_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 */
-
-
-/*
- * Check for a restart marker & resynchronize decoder.
- * Returns FALSE if must suspend.
- */
-
-LOCAL(boolean)
-process_restart(j_decompress_ptr cinfo)
-{
-  huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
-  int ci;
-
-  /* Throw away any unused bits remaining in bit buffer; */
-  /* include any full bytes in next_marker's count of discarded bytes */
-  cinfo->marker->discarded_bytes += entropy->bitstate.bits_left / 8;
-  entropy->bitstate.bits_left = 0;
-
-  /* Advance past the RSTn marker */
-  if (!(*cinfo->marker->read_restart_marker) (cinfo))
-    return FALSE;
-
-  /* Re-initialize DC predictions to 0 */
-  for (ci = 0; ci < cinfo->comps_in_scan; ci++)
-    entropy->saved.last_dc_val[ci] = 0;
-
-  /* Reset restart counter */
-  entropy->restarts_to_go = cinfo->restart_interval;
-
-  /* Reset out-of-data flag, unless read_restart_marker left us smack up
-   * against a marker.  In that case we will end up treating the next data
-   * segment as empty, and we can avoid producing bogus output pixels by
-   * leaving the flag set.
-   */
-  if (cinfo->unread_marker == 0)
-    entropy->pub.insufficient_data = FALSE;
-
-  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_slow(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
-{
-  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;
-
-  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
-    JBLOCKROW block = MCU_data ? MCU_data[blkn] : NULL;
-    d_derived_tbl *dctbl = entropy->dc_cur_tbls[blkn];
-    d_derived_tbl *actbl = entropy->ac_cur_tbls[blkn];
-    register int s, k, r;
-
-    /* Decode a single block's worth of coefficients */
-
-    /* Section F.2.2.1: decode the DC coefficient difference */
-    HUFF_DECODE(s, br_state, dctbl, return FALSE, label1);
-    if (s) {
-      CHECK_BIT_BUFFER(br_state, s, return FALSE);
-      r = GET_BITS(s);
-      s = HUFF_EXTEND(r, s);
-    }
-
-    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;
-      }
-    }
-
-    if (entropy->ac_needed[blkn] && block) {
-
-      /* Section F.2.2.2: decode the AC coefficients */
-      /* Since zeroes are skipped, output area must be cleared beforehand */
-      for (k = 1; k < DCTSIZE2; k++) {
-        HUFF_DECODE(s, br_state, actbl, return FALSE, label2);
-
-        r = s >> 4;
-        s &= 15;
-
-        if (s) {
-          k += r;
-          CHECK_BIT_BUFFER(br_state, s, return FALSE);
-          r = GET_BITS(s);
-          s = HUFF_EXTEND(r, s);
-          /* Output coefficient in natural (dezigzagged) order.
-           * 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;
-        } else {
-          if (r != 15)
-            break;
-          k += 15;
-        }
-      }
-
-    } else {
-
-      /* Section F.2.2.2: decode the AC coefficients */
-      /* In this path we just discard the values */
-      for (k = 1; k < DCTSIZE2; k++) {
-        HUFF_DECODE(s, br_state, actbl, return FALSE, label3);
-
-        r = s >> 4;
-        s &= 15;
-
-        if (s) {
-          k += r;
-          CHECK_BIT_BUFFER(br_state, s, return FALSE);
-          DROP_BITS(s);
-        } else {
-          if (r != 15)
-            break;
-          k += 15;
-        }
-      }
-    }
-  }
-
-  /* Completed MCU, so update state */
-  BITREAD_SAVE_STATE(cinfo, entropy->bitstate);
-  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)
-{
-  huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
-  BITREAD_STATE_VARS;
-  JOCTET *buffer;
-  int blkn;
-  savable_state state;
-  /* 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;
-
-  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
-    JBLOCKROW block = MCU_data ? MCU_data[blkn] : NULL;
-    d_derived_tbl *dctbl = entropy->dc_cur_tbls[blkn];
-    d_derived_tbl *actbl = entropy->ac_cur_tbls[blkn];
-    register int s, k, r, l;
-
-    HUFF_DECODE_FAST(s, l, dctbl);
-    if (s) {
-      FILL_BIT_BUFFER_FAST
-      r = GET_BITS(s);
-      s = HUFF_EXTEND(r, s);
-    }
-
-    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;
-    }
-
-    if (entropy->ac_needed[blkn] && block) {
-
-      for (k = 1; k < DCTSIZE2; k++) {
-        HUFF_DECODE_FAST(s, l, actbl);
-        r = s >> 4;
-        s &= 15;
-
-        if (s) {
-          k += r;
-          FILL_BIT_BUFFER_FAST
-          r = GET_BITS(s);
-          s = HUFF_EXTEND(r, s);
-          (*block)[jpeg_natural_order[k]] = (JCOEF)s;
-        } else {
-          if (r != 15) break;
-          k += 15;
-        }
-      }
-
-    } else {
-
-      for (k = 1; k < DCTSIZE2; k++) {
-        HUFF_DECODE_FAST(s, l, actbl);
-        r = s >> 4;
-        s &= 15;
-
-        if (s) {
-          k += r;
-          FILL_BIT_BUFFER_FAST
-          DROP_BITS(s);
-        } else {
-          if (r != 15) break;
-          k += 15;
-        }
-      }
-    }
-  }
-
-  if (cinfo->unread_marker != 0) {
-    cinfo->unread_marker = 0;
-    return FALSE;
-  }
-
-  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;
-  return TRUE;
-}
-
-
-/*
- * Decode and return one MCU's worth of Huffman-compressed coefficients.
- * The coefficients are reordered from zigzag order into natural array order,
- * but are not dequantized.
- *
- * The i'th block of the MCU is stored into the block pointed to by
- * MCU_data[i].  WE ASSUME THIS AREA HAS BEEN ZEROED BY THE CALLER.
- * (Wholesale zeroing is usually a little faster than retail...)
- *
- * Returns FALSE if data source requested suspension.  In that case no
- * changes have been made to permanent state.  (Exception: some output
- * coefficients may already have been assigned.  This is harmless for
- * this module, since we'll just re-assign them on the next call.)
- */
-
-#define BUFSIZE  (DCTSIZE2 * 8)
-
-METHODDEF(boolean)
-decode_mcu(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
-{
-  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))
-        return FALSE;
-    usefast = 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 (usefast) {
-      if (!decode_mcu_fast(cinfo, MCU_data)) goto 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--;
-
-  return TRUE;
-}
-
-
-/*
- * Module initialization routine for Huffman entropy decoding.
- */
-
-GLOBAL(void)
-jinit_huff_decoder(j_decompress_ptr cinfo)
-{
-  huff_entropy_ptr entropy;
-  int i;
-
-  /* Motion JPEG frames typically do not include the Huffman tables if they
-     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);
-
-  entropy = (huff_entropy_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                sizeof(huff_entropy_decoder));
-  cinfo->entropy = (struct jpeg_entropy_decoder *)entropy;
-  entropy->pub.start_pass = start_pass_huff_decoder;
-  entropy->pub.decode_mcu = decode_mcu;
-
-  /* Mark tables unallocated */
-  for (i = 0; i < NUM_HUFF_TBLS; i++) {
-    entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;
-  }
-}
@@ -1,250 +0,0 @@
-/*
- * jdhuff.h
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1991-1997, Thomas G. Lane.
- * Lossless JPEG Modifications:
- * Copyright (C) 1999, Ken Murchison.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2010-2011, 2015-2016, 2021, D. R. Commander.
- * Copyright (C) 2018, Matthias Räncker.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains declarations for Huffman entropy decoding routines
- * that are shared between the sequential decoder (jdhuff.c), the progressive
- * decoder (jdphuff.c), and the lossless decoder (jdlhuff.c).  No other modules
- * need to see these.
- */
-
-#include "jconfigint.h"
-
-
-/* Derived data constructed for each Huffman table */
-
-#define HUFF_LOOKAHEAD  8       /* # of bits of lookahead */
-
-typedef struct {
-  /* Basic tables: (element [0] of each array is unused) */
-  JLONG maxcode[18];            /* largest code of length k (-1 if none) */
-  /* (maxcode[17] is a sentinel to ensure jpeg_huff_decode terminates) */
-  JLONG valoffset[18];          /* huffval[] offset for codes of length k */
-  /* valoffset[k] = huffval[] index of 1st symbol of code length k, less
-   * the smallest code of length k; so given a code of length k, the
-   * corresponding symbol is huffval[code + valoffset[k]]
-   */
-
-  /* Link to public Huffman table (needed only in jpeg_huff_decode) */
-  JHUFF_TBL *pub;
-
-  /* Lookahead table: indexed by the next HUFF_LOOKAHEAD bits of
-   * the input data stream.  If the next Huffman code is no more
-   * than HUFF_LOOKAHEAD bits long, we can obtain its length and
-   * the corresponding symbol directly from this tables.
-   *
-   * The lower 8 bits of each table entry contain the number of
-   * bits in the corresponding Huffman code, or HUFF_LOOKAHEAD + 1
-   * if too long.  The next 8 bits of each entry contain the
-   * symbol.
-   */
-  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);
-
-
-/*
- * Fetching the next N bits from the input stream is a time-critical operation
- * for the Huffman decoders.  We implement it with a combination of inline
- * macros and out-of-line subroutines.  Note that N (the number of bits
- * demanded at one time) never exceeds 15 for JPEG use.
- *
- * We read source bytes into get_buffer and dole out bits as needed.
- * If get_buffer already contains enough bits, they are fetched in-line
- * by the macros CHECK_BIT_BUFFER and GET_BITS.  When there aren't enough
- * bits, jpeg_fill_bit_buffer is called; it will attempt to fill get_buffer
- * as full as possible (not just to the number of bits needed; this
- * prefetching reduces the overhead cost of calling jpeg_fill_bit_buffer).
- * Note that jpeg_fill_bit_buffer may return FALSE to indicate suspension.
- * On TRUE return, jpeg_fill_bit_buffer guarantees that get_buffer contains
- * at least the requested number of bits --- dummy zeroes are inserted if
- * necessary.
- */
-
-#if !defined(_WIN32) && !defined(SIZEOF_SIZE_T)
-#error Cannot determine word size
-#endif
-
-#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 */
-#define BIT_BUF_SIZE  32                /* size of buffer in bits */
-
-#endif
-
-/* If long is > 32 bits on your machine, and shifting/masking longs is
- * reasonably fast, making bit_buf_type be long and setting BIT_BUF_SIZE
- * appropriately should be a win.  Unfortunately we can't define the size
- * with something like  #define BIT_BUF_SIZE (sizeof(bit_buf_type)*8)
- * because not all machines measure sizeof in 8-bit bytes.
- */
-
-typedef struct {                /* Bitreading state saved across MCUs */
-  bit_buf_type get_buffer;      /* current bit-extraction buffer */
-  int bits_left;                /* # of unused bits in it */
-} bitread_perm_state;
-
-typedef struct {                /* Bitreading working state within an MCU */
-  /* Current data source location */
-  /* We need a copy, rather than munging the original, in case of suspension */
-  const JOCTET *next_input_byte; /* => next byte to read from source */
-  size_t bytes_in_buffer;       /* # of bytes remaining in source buffer */
-  /* Bit input buffer --- note these values are kept in register variables,
-   * not in this struct, inside the inner loops.
-   */
-  bit_buf_type get_buffer;      /* current bit-extraction buffer */
-  int bits_left;                /* # of unused bits in it */
-  /* Pointer needed by jpeg_fill_bit_buffer. */
-  j_decompress_ptr cinfo;       /* back link to decompress master record */
-} 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_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
-
-/*
- * These macros provide the in-line portion of bit fetching.
- * Use CHECK_BIT_BUFFER to ensure there are N bits in get_buffer
- * 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);
- *              Ensure there are N bits in get_buffer; if suspend, take action.
- *      val = GET_BITS(n);
- *              Fetch next N bits.
- *      val = PEEK_BITS(n);
- *              Fetch next N bits without removing them from the buffer.
- *      DROP_BITS(n);
- *              Discard next N bits.
- * The value N should be a simple variable, not an expression, because it
- * 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 GET_BITS(nbits) \
-  (((int)(get_buffer >> (bits_left -= (nbits)))) & ((1 << (nbits)) - 1))
-
-#define PEEK_BITS(nbits) \
-  (((int)(get_buffer >> (bits_left -  (nbits)))) & ((1 << (nbits)) - 1))
-
-#define DROP_BITS(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);
-
-
-/*
- * Code for extracting next Huffman-coded symbol from input bit stream.
- * Again, this is time-critical and we make the main paths be macros.
- *
- * We use a lookahead table to process codes of up to HUFF_LOOKAHEAD bits
- * without looping.  Usually, more than 95% of the Huffman codes will be 8
- * or fewer bits long.  The few overlength codes are handled with a loop,
- * which need not be inline code.
- *
- * Notes about the HUFF_DECODE macro:
- * 1. Near the end of the data segment, we may fail to get enough bits
- *    for a lookahead.  In that case, we do it the hard way.
- * 2. If the lookahead table contains no entry, the next code must be
- *    more than HUFF_LOOKAHEAD bits long.
- * 3. jpeg_huff_decode returns -1 if forced to suspend.
- */
-
-#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 (bits_left < HUFF_LOOKAHEAD) { \
-      nb = 1;  goto slowlabel; \
-    } \
-  } \
-  look = PEEK_BITS(HUFF_LOOKAHEAD); \
-  if ((nb = (htbl->lookup[look] >> HUFF_LOOKAHEAD)) <= HUFF_LOOKAHEAD) { \
-    DROP_BITS(nb); \
-    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; \
-  } \
-}
-
-#define HUFF_DECODE_FAST(s, nb, htbl) \
-  FILL_BIT_BUFFER_FAST; \
-  s = PEEK_BITS(HUFF_LOOKAHEAD); \
-  s = htbl->lookup[s]; \
-  nb = s >> HUFF_LOOKAHEAD; \
-  /* Pre-execute the common case of nb <= HUFF_LOOKAHEAD */ \
-  DROP_BITS(nb); \
-  s = s & ((1 << HUFF_LOOKAHEAD) - 1); \
-  if (nb > HUFF_LOOKAHEAD) { \
-    /* Equivalent of jpeg_huff_decode() */ \
-    /* Don't use GET_BITS() here because we don't want to modify bits_left */ \
-    s = (get_buffer >> bits_left) & ((1 << (nb)) - 1); \
-    while (s > htbl->maxcode[nb]) { \
-      s <<= 1; \
-      s |= GET_BITS(1); \
-      nb++; \
-    } \
-    if (nb > 16) \
-      s = 0; \
-    else \
-      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);
@@ -1,167 +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"
-
-
-#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;
-}
@@ -1,419 +0,0 @@
-/*
- * jdinput.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1991-1997, Thomas G. Lane.
- * Lossless JPEG Modifications:
- * Copyright (C) 1999, Ken Murchison.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2010, 2016, 2018, 2022, D. R. Commander.
- * Copyright (C) 2015, Google, Inc.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains input control logic for the JPEG decompressor.
- * These routines are concerned with controlling the decompressor's input
- * processing (marker reading and coefficient/difference decoding).
- * The actual input reading is done in jdmarker.c, jdhuff.c, jdphuff.c,
- * and jdlhuff.c.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jpegapicomp.h"
-
-
-/* Private state */
-
-typedef struct {
-  struct jpeg_input_controller pub; /* public fields */
-
-  boolean inheaders;            /* TRUE until first SOS is reached */
-} my_input_controller;
-
-typedef my_input_controller *my_inputctl_ptr;
-
-
-/* Forward declarations */
-METHODDEF(int) consume_markers(j_decompress_ptr cinfo);
-
-
-/*
- * Routines to calculate various quantities related to the size of the image.
- */
-
-LOCAL(void)
-initial_setup(j_decompress_ptr cinfo)
-/* Called once, when first SOS marker is reached */
-{
-  int ci;
-  jpeg_component_info *compptr;
-  int data_unit = cinfo->master->lossless ? 1 : DCTSIZE;
-
-  /* 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);
-
-  /* For now, precision must match compiled-in value... */
-#ifdef D_LOSSLESS_SUPPORTED
-  if (cinfo->data_precision != 8 && cinfo->data_precision != 12 &&
-      cinfo->data_precision != 16)
-#else
-  if (cinfo->data_precision != 8 && cinfo->data_precision != 12)
-#endif
-    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-
-  /* Check that number of components won't exceed internal array sizes */
-  if (cinfo->num_components > MAX_COMPONENTS)
-    ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
-             MAX_COMPONENTS);
-
-  /* Compute maximum sampling factors; check factor validity */
-  cinfo->max_h_samp_factor = 1;
-  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)
-      ERREXIT(cinfo, JERR_BAD_SAMPLING);
-    cinfo->max_h_samp_factor = MAX(cinfo->max_h_samp_factor,
-                                   compptr->h_samp_factor);
-    cinfo->max_v_samp_factor = MAX(cinfo->max_v_samp_factor,
-                                   compptr->v_samp_factor);
-  }
-
-#if JPEG_LIB_VERSION >= 80
-  cinfo->block_size = data_unit;
-  cinfo->natural_order = jpeg_natural_order;
-  cinfo->lim_Se = DCTSIZE2 - 1;
-#endif
-
-  /* We initialize DCT_scaled_size and min_DCT_scaled_size to DCTSIZE in lossy
-   * mode.  In the full decompressor, this will be overridden by jdmaster.c;
-   * but in the transcoder, jdmaster.c is not used, so we must do it here.
-   */
-#if JPEG_LIB_VERSION >= 70
-  cinfo->min_DCT_h_scaled_size = cinfo->min_DCT_v_scaled_size = data_unit;
-#else
-  cinfo->min_DCT_scaled_size = data_unit;
-#endif
-
-  /* Compute dimensions of components */
-  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-       ci++, compptr++) {
-#if JPEG_LIB_VERSION >= 70
-    compptr->DCT_h_scaled_size = compptr->DCT_v_scaled_size = data_unit;
-#else
-    compptr->DCT_scaled_size = data_unit;
-#endif
-    /* Size in data units */
-    compptr->width_in_blocks = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_width * (long)compptr->h_samp_factor,
-                    (long)(cinfo->max_h_samp_factor * data_unit));
-    compptr->height_in_blocks = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_height * (long)compptr->v_samp_factor,
-                    (long)(cinfo->max_v_samp_factor * data_unit));
-    /* Set the first and last MCU columns to decompress from multi-scan images.
-     * By default, decompress all of the MCU columns.
-     */
-    cinfo->master->first_MCU_col[ci] = 0;
-    cinfo->master->last_MCU_col[ci] = compptr->width_in_blocks - 1;
-    /* downsampled_width and downsampled_height will also be overridden by
-     * jdmaster.c if we are doing full decompression.  The transcoder library
-     * doesn't use these values, but the calling application might.
-     */
-    /* 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);
-    compptr->downsampled_height = (JDIMENSION)
-      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 */
-    compptr->quant_table = NULL;
-  }
-
-  /* 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 * data_unit));
-
-  /* Decide whether file contains multiple scans */
-  if (cinfo->comps_in_scan < cinfo->num_components || cinfo->progressive_mode)
-    cinfo->inputctl->has_multiple_scans = TRUE;
-  else
-    cinfo->inputctl->has_multiple_scans = FALSE;
-}
-
-
-LOCAL(void)
-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 */
-{
-  int ci, mcublks, tmp;
-  jpeg_component_info *compptr;
-  int data_unit = cinfo->master->lossless ? 1 : DCTSIZE;
-
-  if (cinfo->comps_in_scan == 1) {
-
-    /* Noninterleaved (single-component) scan */
-    compptr = cinfo->cur_comp_info[0];
-
-    /* Overall image size in MCUs */
-    cinfo->MCUs_per_row = compptr->width_in_blocks;
-    cinfo->MCU_rows_in_scan = compptr->height_in_blocks;
-
-    /* For noninterleaved scan, always one data unit per MCU */
-    compptr->MCU_width = 1;
-    compptr->MCU_height = 1;
-    compptr->MCU_blocks = 1;
-    compptr->MCU_sample_width = compptr->_DCT_scaled_size;
-    compptr->last_col_width = 1;
-    /* For noninterleaved scans, it is convenient to define last_row_height
-     * as the number of data unit rows present in the last iMCU row.
-     */
-    tmp = (int)(compptr->height_in_blocks % compptr->v_samp_factor);
-    if (tmp == 0) tmp = compptr->v_samp_factor;
-    compptr->last_row_height = tmp;
-
-    /* Prepare array describing MCU composition */
-    cinfo->blocks_in_MCU = 1;
-    cinfo->MCU_membership[0] = 0;
-
-  } else {
-
-    /* Interleaved (multi-component) scan */
-    if (cinfo->comps_in_scan <= 0 || cinfo->comps_in_scan > MAX_COMPS_IN_SCAN)
-      ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->comps_in_scan,
-               MAX_COMPS_IN_SCAN);
-
-    /* Overall image size in MCUs */
-    cinfo->MCUs_per_row = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_width,
-                    (long)(cinfo->max_h_samp_factor * data_unit));
-    cinfo->MCU_rows_in_scan = (JDIMENSION)
-      jdiv_round_up((long)cinfo->image_height,
-                    (long)(cinfo->max_v_samp_factor * data_unit));
-
-    cinfo->blocks_in_MCU = 0;
-
-    for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
-      compptr = cinfo->cur_comp_info[ci];
-      /* Sampling factors give # of data units of component in each MCU */
-      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;
-      /* Figure number of non-dummy data units in last MCU column & row */
-      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);
-      if (tmp == 0) tmp = compptr->MCU_height;
-      compptr->last_row_height = tmp;
-      /* Prepare array describing MCU composition */
-      mcublks = compptr->MCU_blocks;
-      if (cinfo->blocks_in_MCU + mcublks > D_MAX_BLOCKS_IN_MCU)
-        ERREXIT(cinfo, JERR_BAD_MCU_SIZE);
-      while (mcublks-- > 0) {
-        cinfo->MCU_membership[cinfo->blocks_in_MCU++] = ci;
-      }
-    }
-
-  }
-}
-
-
-/*
- * Save away a copy of the Q-table referenced by each component present
- * in the current scan, unless already saved during a prior scan.
- *
- * In a multiple-scan JPEG file, the encoder could assign different components
- * the same Q-table slot number, but change table definitions between scans
- * so that each component uses a different Q-table.  (The IJG encoder is not
- * currently capable of doing this, but other encoders might.)  Since we want
- * to be able to dequantize all the components at the end of the file, this
- * 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 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)
-{
-  int ci, qtblno;
-  jpeg_component_info *compptr;
-  JQUANT_TBL *qtbl;
-
-  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
-    compptr = cinfo->cur_comp_info[ci];
-    /* No work if we already saved Q-table for this component */
-    if (compptr->quant_table != NULL)
-      continue;
-    /* Make sure specified quantization table is present */
-    qtblno = compptr->quant_tbl_no;
-    if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS ||
-        cinfo->quant_tbl_ptrs[qtblno] == NULL)
-      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,
-                                  sizeof(JQUANT_TBL));
-    memcpy(qtbl, cinfo->quant_tbl_ptrs[qtblno], sizeof(JQUANT_TBL));
-    compptr->quant_table = qtbl;
-  }
-}
-
-
-/*
- * Initialize the input modules to read a scan of compressed data.
- * The first call to this is done by jdmaster.c after initializing
- * the entire decompressor (during jpeg_start_decompress).
- * Subsequent calls come from consume_markers, below.
- */
-
-METHODDEF(void)
-start_input_pass(j_decompress_ptr cinfo)
-{
-  per_scan_setup(cinfo);
-  if (!cinfo->master->lossless)
-    latch_quant_tables(cinfo);
-  (*cinfo->entropy->start_pass) (cinfo);
-  (*cinfo->coef->start_input_pass) (cinfo);
-  cinfo->inputctl->consume_input = cinfo->coef->consume_data;
-}
-
-
-/*
- * Finish up after inputting a compressed-data scan.
- * This is called by the coefficient or difference controller after it's read
- * all the expected data of the scan.
- */
-
-METHODDEF(void)
-finish_input_pass(j_decompress_ptr cinfo)
-{
-  cinfo->inputctl->consume_input = consume_markers;
-}
-
-
-/*
- * Read JPEG markers before, between, or after compressed-data scans.
- * Change state as necessary when a new scan is reached.
- * Return value is JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
- *
- * The consume_input method pointer points either here or to the
- * coefficient or difference controller's consume_data routine, depending on
- * whether we are reading a compressed data segment or inter-segment markers.
- */
-
-METHODDEF(int)
-consume_markers(j_decompress_ptr cinfo)
-{
-  my_inputctl_ptr inputctl = (my_inputctl_ptr)cinfo->inputctl;
-  int val;
-
-  if (inputctl->pub.eoi_reached) /* After hitting EOI, read no further */
-    return JPEG_REACHED_EOI;
-
-  val = (*cinfo->marker->read_markers) (cinfo);
-
-  switch (val) {
-  case JPEG_REACHED_SOS:        /* Found SOS */
-    if (inputctl->inheaders) {  /* 1st SOS */
-      initial_setup(cinfo);
-      inputctl->inheaders = FALSE;
-      /* Note: start_input_pass must be called by jdmaster.c
-       * before any more input can be consumed.  jdapimin.c is
-       * responsible for enforcing this sequencing.
-       */
-    } else {                    /* 2nd or later SOS marker */
-      if (!inputctl->pub.has_multiple_scans)
-        ERREXIT(cinfo, JERR_EOI_EXPECTED); /* Oops, I wasn't expecting this! */
-      start_input_pass(cinfo);
-    }
-    break;
-  case JPEG_REACHED_EOI:        /* Found EOI */
-    inputctl->pub.eoi_reached = TRUE;
-    if (inputctl->inheaders) {  /* Tables-only datastream, apparently */
-      if (cinfo->marker->saw_SOF)
-        ERREXIT(cinfo, JERR_SOF_NO_SOS);
-    } else {
-      /* Prevent infinite loop in coef ctlr's decompress_data routine
-       * if user set output_scan_number larger than number of scans.
-       */
-      if (cinfo->output_scan_number > cinfo->input_scan_number)
-        cinfo->output_scan_number = cinfo->input_scan_number;
-    }
-    break;
-  case JPEG_SUSPENDED:
-    break;
-  }
-
-  return val;
-}
-
-
-/*
- * Reset state to begin a fresh datastream.
- */
-
-METHODDEF(void)
-reset_input_controller(j_decompress_ptr cinfo)
-{
-  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->marker->reset_marker_reader) (cinfo);
-  /* Reset progression state -- would be cleaner if entropy decoder did this */
-  cinfo->coef_bits = NULL;
-}
-
-
-/*
- * Initialize the input controller module.
- * This is called only once, when the decompression object is created.
- */
-
-GLOBAL(void)
-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,
-                                sizeof(my_input_controller));
-  cinfo->inputctl = (struct jpeg_input_controller *)inputctl;
-  /* Initialize method pointers */
-  inputctl->pub.consume_input = consume_markers;
-  inputctl->pub.reset_input_controller = reset_input_controller;
-  inputctl->pub.start_input_pass = start_input_pass;
-  inputctl->pub.finish_input_pass = finish_input_pass;
-  /* Initialize state: can't use reset_input_controller since we don't
-   * want to try to reset other modules yet.
-   */
-  inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */
-  inputctl->pub.eoi_reached = FALSE;
-  inputctl->inheaders = TRUE;
-}
@@ -1,302 +0,0 @@
-/*
- * jdlhuff.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1991-1997, Thomas G. Lane.
- * Lossless JPEG Modifications:
- * Copyright (C) 1999, Ken Murchison.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains Huffman entropy decoding routines for lossless JPEG.
- *
- * Much of the complexity here has to do with supporting input suspension.
- * If the data source module demands suspension, we want to be able to back
- * 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.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jlossls.h"            /* Private declarations for lossless codec */
-#include "jdhuff.h"             /* Declarations shared with jd*huff.c */
-
-
-#ifdef D_LOSSLESS_SUPPORTED
-
-typedef struct {
-  int ci, yoffset, MCU_width;
-} lhd_output_ptr_info;
-
-/*
- * Expanded entropy decoder object for Huffman decoding in lossless mode.
- */
-
-typedef struct {
-  struct jpeg_entropy_decoder pub; /* public fields */
-
-  /* These fields are loaded into local variables at start of each MCU.
-   * In case of suspension, we exit WITHOUT updating them.
-   */
-  bitread_perm_state bitstate;  /* Bit buffer at start of MCU */
-
-  /* Pointers to derived tables (these workspaces have image lifespan) */
-  d_derived_tbl *derived_tbls[NUM_HUFF_TBLS];
-
-  /* Precalculated info set up by start_pass for use in decode_mcus: */
-
-  /* Pointers to derived tables to be used for each data unit within an MCU */
-  d_derived_tbl *cur_tbls[D_MAX_BLOCKS_IN_MCU];
-
-  /* Pointers to the proper output difference row for each group of data units
-   * within an MCU.  For each component, there are Vi groups of Hi data units.
-   */
-  JDIFFROW output_ptr[D_MAX_BLOCKS_IN_MCU];
-
-  /* Number of output pointers in use for the current MCU.  This is the sum
-   * of all Vi in the MCU.
-   */
-  int num_output_ptrs;
-
-  /* Information used for positioning the output pointers within the output
-   * difference rows.
-   */
-  lhd_output_ptr_info output_ptr_info[D_MAX_BLOCKS_IN_MCU];
-
-  /* Index of the proper output pointer for each data unit within an MCU */
-  int output_ptr_index[D_MAX_BLOCKS_IN_MCU];
-
-} lhuff_entropy_decoder;
-
-typedef lhuff_entropy_decoder *lhuff_entropy_ptr;
-
-
-/*
- * Initialize for a Huffman-compressed scan.
- */
-
-METHODDEF(void)
-start_pass_lhuff_decoder(j_decompress_ptr cinfo)
-{
-  lhuff_entropy_ptr entropy = (lhuff_entropy_ptr)cinfo->entropy;
-  int ci, dctbl, sampn, ptrn, yoffset, xoffset;
-  jpeg_component_info *compptr;
-
-  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
-    compptr = cinfo->cur_comp_info[ci];
-    dctbl = compptr->dc_tbl_no;
-    /* Make sure requested tables are present */
-    if (dctbl < 0 || dctbl >= NUM_HUFF_TBLS ||
-        cinfo->dc_huff_tbl_ptrs[dctbl] == NULL)
-      ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, dctbl);
-    /* Compute derived values for Huffman tables */
-    /* We may do this more than once for a table, but it's not expensive */
-    jpeg_make_d_derived_tbl(cinfo, TRUE, dctbl,
-                            &entropy->derived_tbls[dctbl]);
-  }
-
-  /* Precalculate decoding info for each sample in an MCU of this scan */
-  for (sampn = 0, ptrn = 0; sampn < cinfo->blocks_in_MCU;) {
-    compptr = cinfo->cur_comp_info[cinfo->MCU_membership[sampn]];
-    ci = compptr->component_index;
-    for (yoffset = 0; yoffset < compptr->MCU_height; yoffset++, ptrn++) {
-      /* Precalculate the setup info for each output pointer */
-      entropy->output_ptr_info[ptrn].ci = ci;
-      entropy->output_ptr_info[ptrn].yoffset = yoffset;
-      entropy->output_ptr_info[ptrn].MCU_width = compptr->MCU_width;
-      for (xoffset = 0; xoffset < compptr->MCU_width; xoffset++, sampn++) {
-        /* Precalculate the output pointer index for each sample */
-        entropy->output_ptr_index[sampn] = ptrn;
-        /* Precalculate which table to use for each sample */
-        entropy->cur_tbls[sampn] = entropy->derived_tbls[compptr->dc_tbl_no];
-      }
-    }
-  }
-  entropy->num_output_ptrs = ptrn;
-
-  /* Initialize bitread state variables */
-  entropy->bitstate.bits_left = 0;
-  entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */
-  entropy->pub.insufficient_data = FALSE;
-}
-
-
-/*
- * Figure F.12: extend sign bit.
- * On some machines, a shift and add will be faster than a table lookup.
- */
-
-#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)))
-
-#else
-
-#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_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 */
-
-
-/*
- * Check for a restart marker & resynchronize decoder.
- * Returns FALSE if must suspend.
- */
-
-LOCAL(boolean)
-process_restart(j_decompress_ptr cinfo)
-{
-  lhuff_entropy_ptr entropy = (lhuff_entropy_ptr)cinfo->entropy;
-
-  /* Throw away any unused bits remaining in bit buffer; */
-  /* include any full bytes in next_marker's count of discarded bytes */
-  cinfo->marker->discarded_bytes += entropy->bitstate.bits_left / 8;
-  entropy->bitstate.bits_left = 0;
-
-  /* Advance past the RSTn marker */
-  if (!(*cinfo->marker->read_restart_marker) (cinfo))
-    return FALSE;
-
-  /* Reset out-of-data flag, unless read_restart_marker left us smack up
-   * against a marker.  In that case we will end up treating the next data
-   * segment as empty, and we can avoid producing bogus output pixels by
-   * leaving the flag set.
-   */
-  if (cinfo->unread_marker == 0)
-    entropy->pub.insufficient_data = FALSE;
-
-  return TRUE;
-}
-
-
-/*
- * Decode and return nMCU MCUs' worth of Huffman-compressed differences.
- * Each MCU is also disassembled and placed accordingly in diff_buf.
- *
- * MCU_col_num specifies the column of the first MCU being requested within
- * the MCU row.  This tells us where to position the output row pointers in
- * diff_buf.
- *
- * Returns the number of MCUs decoded.  This may be less than nMCU MCUs if
- * data source requested suspension.  In that case no changes have been made
- * to permanent state.  (Exception: some output differences may already have
- * been assigned.  This is harmless for this module, since we'll just
- * re-assign them on the next call.)
- */
-
-METHODDEF(JDIMENSION)
-decode_mcus(j_decompress_ptr cinfo, JDIFFIMAGE diff_buf,
-            JDIMENSION MCU_row_num, JDIMENSION MCU_col_num, JDIMENSION nMCU)
-{
-  lhuff_entropy_ptr entropy = (lhuff_entropy_ptr)cinfo->entropy;
-  int sampn, ci, yoffset, MCU_width, ptrn;
-  JDIMENSION mcu_num;
-  BITREAD_STATE_VARS;
-
-  /* Set output pointer locations based on MCU_col_num */
-  for (ptrn = 0; ptrn < entropy->num_output_ptrs; ptrn++) {
-    ci = entropy->output_ptr_info[ptrn].ci;
-    yoffset = entropy->output_ptr_info[ptrn].yoffset;
-    MCU_width = entropy->output_ptr_info[ptrn].MCU_width;
-    entropy->output_ptr[ptrn] =
-      diff_buf[ci][MCU_row_num + yoffset] + (MCU_col_num * MCU_width);
-  }
-
-  /*
-   * If we've run out of data, zero out the buffers and return.
-   * By resetting the undifferencer, the output samples will be CENTERJSAMPLE.
-   *
-   * NB: We should find a way to do this without interacting with the
-   * undifferencer module directly.
-   */
-  if (entropy->pub.insufficient_data) {
-    for (ptrn = 0; ptrn < entropy->num_output_ptrs; ptrn++)
-      jzero_far((void FAR *)entropy->output_ptr[ptrn],
-                nMCU * entropy->output_ptr_info[ptrn].MCU_width *
-                sizeof(JDIFF));
-
-    (*cinfo->idct->start_pass) (cinfo);
-
-  } else {
-
-    /* Load up working state */
-    BITREAD_LOAD_STATE(cinfo, entropy->bitstate);
-
-    /* Outer loop handles the number of MCUs requested */
-
-    for (mcu_num = 0; mcu_num < nMCU; mcu_num++) {
-
-      /* Inner loop handles the samples in the MCU */
-      for (sampn = 0; sampn < cinfo->blocks_in_MCU; sampn++) {
-        d_derived_tbl *dctbl = entropy->cur_tbls[sampn];
-        register int s, r;
-
-        /* Section H.2.2: decode the sample difference */
-        HUFF_DECODE(s, br_state, dctbl, return mcu_num, label1);
-        if (s) {
-          if (s == 16)  /* special case: always output 32768 */
-            s = 32768;
-          else {        /* normal case: fetch subsequent bits */
-            CHECK_BIT_BUFFER(br_state, s, return mcu_num);
-            r = GET_BITS(s);
-            s = HUFF_EXTEND(r, s);
-          }
-        }
-
-        /* Output the sample difference */
-        *entropy->output_ptr[entropy->output_ptr_index[sampn]]++ = (JDIFF)s;
-      }
-
-      /* Completed MCU, so update state */
-      BITREAD_SAVE_STATE(cinfo, entropy->bitstate);
-    }
-  }
-
- return nMCU;
-}
-
-
-/*
- * Module initialization routine for lossless mode Huffman entropy decoding.
- */
-
-GLOBAL(void)
-jinit_lhuff_decoder(j_decompress_ptr cinfo)
-{
-  lhuff_entropy_ptr entropy;
-  int i;
-
-  entropy = (lhuff_entropy_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                sizeof(lhuff_entropy_decoder));
-  cinfo->entropy = (struct jpeg_entropy_decoder *)entropy;
-  entropy->pub.start_pass = start_pass_lhuff_decoder;
-  entropy->pub.decode_mcus = decode_mcus;
-  entropy->pub.process_restart = process_restart;
-
-  /* Mark tables unallocated */
-  for (i = 0; i < NUM_HUFF_TBLS; i++) {
-    entropy->derived_tbls[i] = NULL;
-  }
-}
-
-#endif /* D_LOSSLESS_SUPPORTED */
@@ -1,289 +0,0 @@
-/*
- * jdlossls.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1998, Thomas G. Lane.
- * Lossless JPEG Modifications:
- * Copyright (C) 1999, Ken Murchison.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains prediction, sample undifferencing, point transform, and
- * sample scaling routines for the lossless JPEG decompressor.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jlossls.h"
-
-#ifdef D_LOSSLESS_SUPPORTED
-
-
-/**************** Sample undifferencing (reconstruction) *****************/
-
-/*
- * In order to avoid a performance penalty for checking which predictor is
- * being used and which row is being processed for each call of the
- * undifferencer, and to promote optimization, we have separate undifferencing
- * functions for each predictor selection value.
- *
- * We are able to avoid duplicating source code by implementing the predictors
- * and undifferencers as macros.  Each of the undifferencing functions is
- * simply a wrapper around an UNDIFFERENCE macro with the appropriate PREDICTOR
- * macro passed as an argument.
- */
-
-/* Predictor for the first column of the first row: 2^(P-Pt-1) */
-#define INITIAL_PREDICTORx  (1 << (cinfo->data_precision - cinfo->Al - 1))
-
-/* Predictor for the first column of the remaining rows: Rb */
-#define INITIAL_PREDICTOR2  prev_row[0]
-
-
-/*
- * 1-Dimensional undifferencer routine.
- *
- * This macro implements the 1-D horizontal predictor (1).  INITIAL_PREDICTOR
- * is used as the special case predictor for the first column, which must be
- * either INITIAL_PREDICTOR2 or INITIAL_PREDICTORx.  The remaining samples
- * use PREDICTOR1.
- *
- * The reconstructed sample is supposed to be calculated modulo 2^16, so we
- * logically AND the result with 0xFFFF.
- */
-
-#define UNDIFFERENCE_1D(INITIAL_PREDICTOR) \
-  int Ra; \
-  \
-  Ra = (*diff_buf++ + INITIAL_PREDICTOR) & 0xFFFF; \
-  *undiff_buf++ = Ra; \
-  \
-  while (--width) { \
-    Ra = (*diff_buf++ + PREDICTOR1) & 0xFFFF; \
-    *undiff_buf++ = Ra; \
-  }
-
-
-/*
- * 2-Dimensional undifferencer routine.
- *
- * This macro implements the 2-D horizontal predictors (#2-7).  PREDICTOR2 is
- * used as the special case predictor for the first column.  The remaining
- * samples use PREDICTOR, which is a function of Ra, Rb, and Rc.
- *
- * Because prev_row and output_buf may point to the same storage area (in an
- * interleaved image with Vi=1, for example), we must take care to buffer Rb/Rc
- * before writing the current reconstructed sample value into output_buf.
- *
- * The reconstructed sample is supposed to be calculated modulo 2^16, so we
- * logically AND the result with 0xFFFF.
- */
-
-#define UNDIFFERENCE_2D(PREDICTOR) \
-  int Ra, Rb, Rc; \
-  \
-  Rb = *prev_row++; \
-  Ra = (*diff_buf++ + PREDICTOR2) & 0xFFFF; \
-  *undiff_buf++ = Ra; \
-  \
-  while (--width) { \
-    Rc = Rb; \
-    Rb = *prev_row++; \
-    Ra = (*diff_buf++ + PREDICTOR) & 0xFFFF; \
-    *undiff_buf++ = Ra; \
-  }
-
-
-/*
- * Undifferencers for the second and subsequent rows in a scan or restart
- * interval.  The first sample in the row is undifferenced using the vertical
- * predictor (2).  The rest of the samples are undifferenced using the
- * predictor specified in the scan header.
- */
-
-METHODDEF(void)
-jpeg_undifference1(j_decompress_ptr cinfo, int comp_index,
-                   JDIFFROW diff_buf, JDIFFROW prev_row,
-                   JDIFFROW undiff_buf, JDIMENSION width)
-{
-  UNDIFFERENCE_1D(INITIAL_PREDICTOR2);
-}
-
-METHODDEF(void)
-jpeg_undifference2(j_decompress_ptr cinfo, int comp_index,
-                   JDIFFROW diff_buf, JDIFFROW prev_row,
-                   JDIFFROW undiff_buf, JDIMENSION width)
-{
-  UNDIFFERENCE_2D(PREDICTOR2);
-  (void)(Rc);
-}
-
-METHODDEF(void)
-jpeg_undifference3(j_decompress_ptr cinfo, int comp_index,
-                   JDIFFROW diff_buf, JDIFFROW prev_row,
-                   JDIFFROW undiff_buf, JDIMENSION width)
-{
-  UNDIFFERENCE_2D(PREDICTOR3);
-}
-
-METHODDEF(void)
-jpeg_undifference4(j_decompress_ptr cinfo, int comp_index,
-                   JDIFFROW diff_buf, JDIFFROW prev_row,
-                   JDIFFROW undiff_buf, JDIMENSION width)
-{
-  UNDIFFERENCE_2D(PREDICTOR4);
-}
-
-METHODDEF(void)
-jpeg_undifference5(j_decompress_ptr cinfo, int comp_index,
-                   JDIFFROW diff_buf, JDIFFROW prev_row,
-                   JDIFFROW undiff_buf, JDIMENSION width)
-{
-  UNDIFFERENCE_2D(PREDICTOR5);
-}
-
-METHODDEF(void)
-jpeg_undifference6(j_decompress_ptr cinfo, int comp_index,
-                   JDIFFROW diff_buf, JDIFFROW prev_row,
-                   JDIFFROW undiff_buf, JDIMENSION width)
-{
-  UNDIFFERENCE_2D(PREDICTOR6);
-}
-
-METHODDEF(void)
-jpeg_undifference7(j_decompress_ptr cinfo, int comp_index,
-                   JDIFFROW diff_buf, JDIFFROW prev_row,
-                   JDIFFROW undiff_buf, JDIMENSION width)
-{
-  UNDIFFERENCE_2D(PREDICTOR7);
-  (void)(Rc);
-}
-
-
-/*
- * Undifferencer for the first row in a scan or restart interval.  The first
- * sample in the row is undifferenced using the special predictor constant
- * x=2^(P-Pt-1).  The rest of the samples are undifferenced using the
- * 1-D horizontal predictor (1).
- */
-
-METHODDEF(void)
-jpeg_undifference_first_row(j_decompress_ptr cinfo, int comp_index,
-                            JDIFFROW diff_buf, JDIFFROW prev_row,
-                            JDIFFROW undiff_buf, JDIMENSION width)
-{
-  lossless_decomp_ptr losslessd = (lossless_decomp_ptr)cinfo->idct;
-
-  UNDIFFERENCE_1D(INITIAL_PREDICTORx);
-
-  /*
-   * Now that we have undifferenced the first row, we want to use the
-   * undifferencer that corresponds to the predictor specified in the
-   * scan header.
-   */
-  switch (cinfo->Ss) {
-  case 1:
-    losslessd->predict_undifference[comp_index] = jpeg_undifference1;
-    break;
-  case 2:
-    losslessd->predict_undifference[comp_index] = jpeg_undifference2;
-    break;
-  case 3:
-    losslessd->predict_undifference[comp_index] = jpeg_undifference3;
-    break;
-  case 4:
-    losslessd->predict_undifference[comp_index] = jpeg_undifference4;
-    break;
-  case 5:
-    losslessd->predict_undifference[comp_index] = jpeg_undifference5;
-    break;
-  case 6:
-    losslessd->predict_undifference[comp_index] = jpeg_undifference6;
-    break;
-  case 7:
-    losslessd->predict_undifference[comp_index] = jpeg_undifference7;
-    break;
-  }
-}
-
-
-/*********************** Sample upscaling by 2^Pt ************************/
-
-METHODDEF(void)
-simple_upscale(j_decompress_ptr cinfo,
-               JDIFFROW diff_buf, _JSAMPROW output_buf, JDIMENSION width)
-{
-  do {
-    *output_buf++ = (_JSAMPLE)(*diff_buf++ << cinfo->Al);
-  } while (--width);
-}
-
-METHODDEF(void)
-noscale(j_decompress_ptr cinfo,
-        JDIFFROW diff_buf, _JSAMPROW output_buf, JDIMENSION width)
-{
-  do {
-    *output_buf++ = (_JSAMPLE)(*diff_buf++);
-  } while (--width);
-}
-
-
-/*
- * Initialize for an input processing pass.
- */
-
-METHODDEF(void)
-start_pass_lossless(j_decompress_ptr cinfo)
-{
-  lossless_decomp_ptr losslessd = (lossless_decomp_ptr)cinfo->idct;
-  int ci;
-
-  /* Check that the scan parameters Ss, Se, Ah, Al are OK for lossless JPEG.
-   *
-   * Ss is the predictor selection value (psv).  Legal values for sequential
-   * lossless JPEG are: 1 <= psv <= 7.
-   *
-   * Se and Ah are not used and should be zero.
-   *
-   * Al specifies the point transform (Pt).
-   * Legal values are: 0 <= Pt <= (data precision - 1).
-   */
-  if (cinfo->Ss < 1 || cinfo->Ss > 7 ||
-      cinfo->Se != 0 || cinfo->Ah != 0 ||
-      cinfo->Al < 0 || cinfo->Al >= cinfo->data_precision)
-    ERREXIT4(cinfo, JERR_BAD_PROGRESSION,
-             cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al);
-
-  /* Set undifference functions to first row function */
-  for (ci = 0; ci < cinfo->num_components; ci++)
-    losslessd->predict_undifference[ci] = jpeg_undifference_first_row;
-
-  /* Set scaler function based on Pt */
-  if (cinfo->Al)
-    losslessd->scaler_scale = simple_upscale;
-  else
-    losslessd->scaler_scale = noscale;
-}
-
-
-/*
- * Initialize the lossless decompressor.
- */
-
-GLOBAL(void)
-_jinit_lossless_decompressor(j_decompress_ptr cinfo)
-{
-  lossless_decomp_ptr losslessd;
-
-  /* Create subobject in permanent pool */
-  losslessd = (lossless_decomp_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
-                                sizeof(jpeg_lossless_decompressor));
-  cinfo->idct = (struct jpeg_inverse_dct *)losslessd;
-  losslessd->pub.start_pass = start_pass_lossless;
-}
-
-#endif /* D_LOSSLESS_SUPPORTED */
@@ -1,469 +0,0 @@
-/*
- * jdmainct.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1994-1996, Thomas G. Lane.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2010, 2016, 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains the main buffer controller for decompression.
- * The main buffer lies between the JPEG decompressor proper and the
- * post-processor; it holds downsampled data in the JPEG colorspace.
- *
- * Note that this code is bypassed in raw-data mode, since the application
- * supplies the equivalent of the main buffer in that case.
- */
-
-#include "jinclude.h"
-#include "jdmainct.h"
-
-
-#if BITS_IN_JSAMPLE != 16 || defined(D_LOSSLESS_SUPPORTED)
-
-/*
- * In the current system design, the main buffer need never be a full-image
- * buffer; any full-height buffers will be found inside the coefficient,
- * difference, or postprocessing controllers.  Nonetheless, the main controller
- * is not trivial.  Its responsibility is to provide context rows for
- * upsampling/rescaling, and doing this in an efficient fashion is a bit
- * tricky.
- *
- * Postprocessor input data is counted in "row groups".  A row group
- * is defined to be (v_samp_factor * DCT_scaled_size / min_DCT_scaled_size)
- * sample rows of each component.  (We require DCT_scaled_size values to be
- * chosen such that these numbers are integers.  In practice DCT_scaled_size
- * values will likely be powers of two, so we actually have the stronger
- * condition that DCT_scaled_size / min_DCT_scaled_size is an integer.)
- * Upsampling will typically produce max_v_samp_factor pixel rows from each
- * row group (times any additional scale factor that the upsampler is
- * applying).
- *
- * The coefficient or difference controller will deliver data to us one iMCU
- * row at a time; each iMCU row contains v_samp_factor * DCT_scaled_size sample
- * rows, or exactly min_DCT_scaled_size row groups.  (This amount of data
- * corresponds to one row of MCUs when the image is fully interleaved.)  Note
- * that the number of sample rows varies across components, but the number of
- * row groups does not.  Some garbage sample rows may be included in the last
- * iMCU row at the bottom of the image.
- *
- * Depending on the vertical scaling algorithm used, the upsampler may need
- * access to the sample row(s) above and below its current input row group.
- * The upsampler is required to set need_context_rows TRUE at global selection
- * time if so.  When need_context_rows is FALSE, this controller can simply
- * obtain one iMCU row at a time from the coefficient or difference controller
- * and dole it out as row groups to the postprocessor.
- *
- * When need_context_rows is TRUE, this controller guarantees that the buffer
- * passed to postprocessing contains at least one row group's worth of samples
- * above and below the row group(s) being processed.  Note that the context
- * rows "above" the first passed row group appear at negative row offsets in
- * the passed buffer.  At the top and bottom of the image, the required
- * context rows are manufactured by duplicating the first or last real sample
- * row; this avoids having special cases in the upsampling inner loops.
- *
- * The amount of context is fixed at one row group just because that's a
- * convenient number for this controller to work with.  The existing
- * upsamplers really only need one sample row of context.  An upsampler
- * supporting arbitrary output rescaling might wish for more than one row
- * group of context when shrinking the image; tough, we don't handle that.
- * (This is justified by the assumption that downsizing will be handled mostly
- * by adjusting the DCT_scaled_size values, so that the actual scale factor at
- * the upsample step needn't be much less than one.)
- *
- * To provide the desired context, we have to retain the last two row groups
- * of one iMCU row while reading in the next iMCU row.  (The last row group
- * can't be processed until we have another row group for its below-context,
- * and so we have to save the next-to-last group too for its above-context.)
- * We could do this most simply by copying data around in our buffer, but
- * that'd be very slow.  We can avoid copying any data by creating a rather
- * strange pointer structure.  Here's how it works.  We allocate a workspace
- * consisting of M+2 row groups (where M = min_DCT_scaled_size is the number
- * of row groups per iMCU row).  We create two sets of redundant pointers to
- * the workspace.  Labeling the physical row groups 0 to M+1, the synthesized
- * pointer lists look like this:
- *                   M+1                          M-1
- * master pointer --> 0         master pointer --> 0
- *                    1                            1
- *                   ...                          ...
- *                   M-3                          M-3
- *                   M-2                           M
- *                   M-1                          M+1
- *                    M                           M-2
- *                   M+1                          M-1
- *                    0                            0
- * We read alternate iMCU rows using each master pointer; thus the last two
- * row groups of the previous iMCU row remain un-overwritten in the workspace.
- * The pointer lists are set up so that the required context rows appear to
- * be adjacent to the proper places when we pass the pointer lists to the
- * upsampler.
- *
- * The above pictures describe the normal state of the pointer lists.
- * At top and bottom of the image, we diddle the pointer lists to duplicate
- * the first or last sample row as necessary (this is cheaper than copying
- * sample rows around).
- *
- * This scheme breaks down if M < 2, ie, min_DCT_scaled_size is 1.  In that
- * situation each iMCU row provides only one row group so the buffering logic
- * must be different (eg, we must read two iMCU rows before we can emit the
- * first row group).  For now, we simply do not support providing context
- * rows when min_DCT_scaled_size is 1.  That combination seems unlikely to
- * be worth providing --- if someone wants a 1/8th-size preview, they probably
- * want it quick and dirty, so a context-free upsampler is sufficient.
- */
-
-
-/* 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);
-#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);
-#endif
-
-
-LOCAL(void)
-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;
-  int ci, rgroup;
-  int M = cinfo->_min_DCT_scaled_size;
-  jpeg_component_info *compptr;
-  _JSAMPARRAY xbuf;
-
-  /* Get top-level space for component array pointers.
-   * 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->num_components * 2 *
-                                sizeof(_JSAMPARRAY));
-  main_ptr->xbuffer[1] = main_ptr->xbuffer[0] + cinfo->num_components;
-
-  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-       ci++, compptr++) {
-    rgroup = (compptr->v_samp_factor * compptr->_DCT_scaled_size) /
-      cinfo->_min_DCT_scaled_size; /* height of a row group of component */
-    /* Get space for pointer lists --- M+4 row groups in each list.
-     * 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,
-                                  2 * (rgroup * (M + 4)) * sizeof(_JSAMPROW));
-    xbuf += rgroup;             /* want one row group at negative offsets */
-    main_ptr->xbuffer[0][ci] = xbuf;
-    xbuf += rgroup * (M + 4);
-    main_ptr->xbuffer[1][ci] = xbuf;
-  }
-}
-
-
-LOCAL(void)
-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.
- * This routine just fills in the curiously ordered lists.
- * This will be repeated at the beginning of each pass.
- */
-{
-  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;
-  _JSAMPARRAY buf, xbuf0, xbuf1;
-
-  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-       ci++, compptr++) {
-    rgroup = (compptr->v_samp_factor * compptr->_DCT_scaled_size) /
-      cinfo->_min_DCT_scaled_size; /* height of a row group of component */
-    xbuf0 = main_ptr->xbuffer[0][ci];
-    xbuf1 = main_ptr->xbuffer[1][ci];
-    /* First copy the workspace pointers as-is */
-    buf = main_ptr->buffer[ci];
-    for (i = 0; i < rgroup * (M + 2); i++) {
-      xbuf0[i] = xbuf1[i] = buf[i];
-    }
-    /* 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];
-    }
-    /* The wraparound pointers at top and bottom will be filled later
-     * (see set_wraparound_pointers, below).  Initially we want the "above"
-     * pointers to duplicate the first actual data line.  This only needs
-     * to happen in xbuffer[0].
-     */
-    for (i = 0; i < rgroup; i++) {
-      xbuf0[i - rgroup] = xbuf0[0];
-    }
-  }
-}
-
-
-LOCAL(void)
-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;
-  int ci, i, rgroup, iMCUheight, rows_left;
-  jpeg_component_info *compptr;
-  _JSAMPARRAY xbuf;
-
-  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-       ci++, compptr++) {
-    /* Count sample rows in one iMCU row and in one row group */
-    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);
-    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);
-    }
-    /* 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];
-    }
-  }
-}
-
-
-/*
- * Initialize for a processing pass.
- */
-
-METHODDEF(void)
-start_pass_main(j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
-{
-  my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
-
-  switch (pass_mode) {
-  case JBUF_PASS_THRU:
-    if (cinfo->upsample->need_context_rows) {
-      main_ptr->pub._process_data = process_data_context_main;
-      make_funny_pointers(cinfo); /* Create the xbuffer[] lists */
-      main_ptr->whichptr = 0;   /* Read first iMCU row into xbuffer[0] */
-      main_ptr->context_state = CTX_PREPARE_FOR_IMCU;
-      main_ptr->iMCU_row_ctr = 0;
-    } else {
-      /* Simple case with no context needed */
-      main_ptr->pub._process_data = process_data_simple_main;
-    }
-    main_ptr->buffer_full = FALSE;      /* Mark buffer empty */
-    main_ptr->rowgroup_ctr = 0;
-    break;
-#ifdef QUANT_2PASS_SUPPORTED
-  case JBUF_CRANK_DEST:
-    /* For last pass of 2-pass quantization, just crank the postprocessor */
-    main_ptr->pub._process_data = process_data_crank_post;
-    break;
-#endif
-  default:
-    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
-    break;
-  }
-}
-
-
-/*
- * Process some data.
- * This handles the simple case where no context is required.
- */
-
-METHODDEF(void)
-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;
-  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))
-      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;
-  /* 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.
-   */
-
-  /* Feed the postprocessor */
-  (*cinfo->post->_post_process_data) (cinfo, main_ptr->buffer,
-                                      &main_ptr->rowgroup_ctr, rowgroups_avail,
-                                      output_buf, out_row_ctr, out_rows_avail);
-
-  /* Has postprocessor consumed all the data yet? If so, mark buffer empty */
-  if (main_ptr->rowgroup_ctr >= rowgroups_avail) {
-    main_ptr->buffer_full = FALSE;
-    main_ptr->rowgroup_ctr = 0;
-  }
-}
-
-
-/*
- * Process some data.
- * This handles the case where context rows must be provided.
- */
-
-METHODDEF(void)
-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;
-
-  /* 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]))
-      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 */
-  }
-
-  /* Postprocessor typically will not swallow all the input data it is handed
-   * in one call (due to filling the output buffer first).  Must be prepared
-   * to exit and restart.  This switch lets us keep track of how far we got.
-   * Note that each case falls through to the next on successful completion.
-   */
-  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);
-    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*/
-  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);
-    /* 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*/
-  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);
-    if (main_ptr->rowgroup_ctr < main_ptr->rowgroups_avail)
-      return;                   /* Need to suspend */
-    /* After the first iMCU, change wraparound pointers to normal state */
-    if (main_ptr->iMCU_row_ctr == 1)
-      set_wraparound_pointers(cinfo);
-    /* Prepare to load new iMCU row using other xbuffer list */
-    main_ptr->whichptr ^= 1;    /* 0=>1 or 1=>0 */
-    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->context_state = CTX_POSTPONED_ROW;
-  }
-}
-
-
-/*
- * Process some data.
- * Final pass of two-pass quantization: just call the postprocessor.
- * Source data will be the postprocessor controller's internal buffer.
- */
-
-#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)
-{
-  (*cinfo->post->_post_process_data) (cinfo, (_JSAMPIMAGE)NULL,
-                                      (JDIMENSION *)NULL, (JDIMENSION)0,
-                                      output_buf, out_row_ctr, out_rows_avail);
-}
-
-#endif /* QUANT_2PASS_SUPPORTED */
-
-
-/*
- * Initialize main buffer controller.
- */
-
-GLOBAL(void)
-_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;
-
-  if (cinfo->data_precision != BITS_IN_JSAMPLE)
-    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-
-  main_ptr = (my_main_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                sizeof(my_main_controller));
-  cinfo->main = (struct jpeg_d_main_controller *)main_ptr;
-  main_ptr->pub.start_pass = start_pass_main;
-
-  if (need_full_buffer)         /* shouldn't happen */
-    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
-
-  /* Allocate the workspace.
-   * ngroups is the number of row groups we need.
-   */
-  if (cinfo->upsample->need_context_rows) {
-    if (cinfo->_min_DCT_scaled_size < 2) /* unsupported, see comments above */
-      ERREXIT(cinfo, JERR_NOTIMPL);
-    alloc_funny_pointers(cinfo); /* Alloc space for xbuffer[] lists */
-    ngroups = cinfo->_min_DCT_scaled_size + 2;
-  } else {
-    ngroups = cinfo->_min_DCT_scaled_size;
-  }
-
-  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-       ci++, compptr++) {
-    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] = (_JSAMPARRAY)(*cinfo->mem->alloc_sarray)
-                        ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                         compptr->width_in_blocks * compptr->_DCT_scaled_size,
-                         (JDIMENSION)(rgroup * ngroups));
-  }
-}
-
-#endif /* BITS_IN_JSAMPLE != 16 || defined(D_LOSSLESS_SUPPORTED) */
@@ -1,78 +0,0 @@
-/*
- * jdmainct.h
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1994-1996, Thomas G. Lane.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- */
-
-#define JPEG_INTERNALS
-#include "jpeglib.h"
-#include "jpegapicomp.h"
-#include "jsamplecomp.h"
-
-
-#if BITS_IN_JSAMPLE != 16 || defined(D_LOSSLESS_SUPPORTED)
-
-/* Private buffer controller object */
-
-typedef struct {
-  struct jpeg_d_main_controller pub; /* public fields */
-
-  /* Pointer to allocated workspace (M or M+2 row groups). */
-  _JSAMPARRAY buffer[MAX_COMPONENTS];
-
-  boolean buffer_full;          /* Have we gotten an iMCU row from decoder? */
-  JDIMENSION rowgroup_ctr;      /* counts row groups output to postprocessor */
-
-  /* Remaining fields are only used in the context case. */
-
-  /* These are the master pointers to the funny-order pointer lists. */
-  _JSAMPIMAGE xbuffer[2];       /* pointers to weird pointer lists */
-
-  int whichptr;                 /* indicates which pointer set is now in use */
-  int context_state;            /* process_data state machine status */
-  JDIMENSION rowgroups_avail;   /* row groups available to postprocessor */
-  JDIMENSION iMCU_row_ctr;      /* counts iMCU rows to detect image top/bot */
-} my_main_controller;
-
-typedef my_main_controller *my_main_ptr;
-
-
-/* context_state values: */
-#define CTX_PREPARE_FOR_IMCU    0       /* need to prepare for MCU row */
-#define CTX_PROCESS_IMCU        1       /* feeding iMCU to postprocessor */
-#define CTX_POSTPONED_ROW       2       /* feeding postponed row group */
-
-
-LOCAL(void)
-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;
-  int ci, i, rgroup;
-  int M = cinfo->_min_DCT_scaled_size;
-  jpeg_component_info *compptr;
-  _JSAMPARRAY xbuf0, xbuf1;
-
-  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-       ci++, compptr++) {
-    rgroup = (compptr->v_samp_factor * compptr->_DCT_scaled_size) /
-      cinfo->_min_DCT_scaled_size; /* height of a row group of component */
-    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];
-    }
-  }
-}
-
-#endif /* BITS_IN_JSAMPLE != 16 || defined(D_LOSSLESS_SUPPORTED) */
@@ -1,891 +0,0 @@
-/*
- * jdmaster.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1991-1997, Thomas G. Lane.
- * Modified 2002-2009 by Guido Vollbeding.
- * Lossless JPEG Modifications:
- * Copyright (C) 1999, Ken Murchison.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2009-2011, 2016, 2019, 2022-2023, D. R. Commander.
- * Copyright (C) 2013, Linaro Limited.
- * Copyright (C) 2015, Google, Inc.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains master control logic for the JPEG decompressor.
- * These routines are concerned with selecting the modules to be executed
- * and with determining the number of passes and the work to be done in each
- * pass.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jpegapicomp.h"
-#include "jdmaster.h"
-
-
-/*
- * Determine whether merged upsample/color conversion should be used.
- * CRUCIAL: this must match the actual capabilities of jdmerge.c!
- */
-
-LOCAL(boolean)
-use_merged_upsample(j_decompress_ptr cinfo)
-{
-#ifdef UPSAMPLE_MERGING_SUPPORTED
-  /* Colorspace conversion is not supported with lossless JPEG images */
-  if (cinfo->master->lossless)
-    return FALSE;
-  /* Merging is the equivalent of plain box-filter upsampling */
-  if (cinfo->do_fancy_upsampling || cinfo->CCIR601_sampling)
-    return FALSE;
-  /* 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))
-    return FALSE;
-  if ((cinfo->out_color_space == JCS_RGB565 &&
-       cinfo->out_color_components != 3) ||
-      (cinfo->out_color_space != JCS_RGB565 &&
-       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 ||
-      cinfo->comp_info[1].h_samp_factor != 1 ||
-      cinfo->comp_info[2].h_samp_factor != 1 ||
-      cinfo->comp_info[0].v_samp_factor >  2 ||
-      cinfo->comp_info[1].v_samp_factor != 1 ||
-      cinfo->comp_info[2].v_samp_factor != 1)
-    return FALSE;
-  /* furthermore, it doesn't work if we've scaled the IDCTs differently */
-  if (cinfo->comp_info[0]._DCT_scaled_size != cinfo->_min_DCT_scaled_size ||
-      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;
-  /* ??? also need to test for upsample-time rescaling, when & if supported */
-  return TRUE;                  /* by golly, it'll work... */
-#else
-  return FALSE;
-#endif
-}
-
-
-/*
- * Compute output image dimensions and related values.
- * NOTE: this is exported for possible use by application.
- * Hence it mustn't do anything that can't be done twice.
- */
-
-#if JPEG_LIB_VERSION >= 80
-GLOBAL(void)
-#else
-LOCAL(void)
-#endif
-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.
- */
-{
-#ifdef IDCT_SCALING_SUPPORTED
-  int ci;
-  jpeg_component_info *compptr;
-
-  if (!cinfo->master->lossless) {
-    /* Compute actual output image dimensions and DCT scaling choices. */
-    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);
-      cinfo->output_height = (JDIMENSION)
-        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);
-      cinfo->output_height = (JDIMENSION)
-        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);
-      cinfo->output_height = (JDIMENSION)
-        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);
-      cinfo->output_height = (JDIMENSION)
-        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);
-      cinfo->output_height = (JDIMENSION)
-        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);
-      cinfo->output_height = (JDIMENSION)
-        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);
-      cinfo->output_height = (JDIMENSION)
-        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);
-      cinfo->output_height = (JDIMENSION)
-        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);
-      cinfo->output_height = (JDIMENSION)
-        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);
-      cinfo->output_height = (JDIMENSION)
-        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);
-      cinfo->output_height = (JDIMENSION)
-        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);
-      cinfo->output_height = (JDIMENSION)
-        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);
-      cinfo->output_height = (JDIMENSION)
-        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);
-      cinfo->output_height = (JDIMENSION)
-        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);
-      cinfo->output_height = (JDIMENSION)
-        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);
-      cinfo->output_height = (JDIMENSION)
-        jdiv_round_up((long)cinfo->image_height * 16L, (long)DCTSIZE);
-      cinfo->_min_DCT_h_scaled_size = 16;
-      cinfo->_min_DCT_v_scaled_size = 16;
-    }
-
-    /* Recompute dimensions of components */
-    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-         ci++, compptr++) {
-      compptr->_DCT_h_scaled_size = cinfo->_min_DCT_h_scaled_size;
-      compptr->_DCT_v_scaled_size = cinfo->_min_DCT_v_scaled_size;
-    }
-  } else
-#endif /* !IDCT_SCALING_SUPPORTED */
-  {
-    /* Hardwire it to "no scaling" */
-    cinfo->output_width = cinfo->image_width;
-    cinfo->output_height = cinfo->image_height;
-    /* jdinput.c has already initialized DCT_scaled_size,
-     * and has computed unscaled downsampled_width and downsampled_height.
-     */
-  }
-}
-
-
-/*
- * Compute output image dimensions and related values.
- * NOTE: this is exported for possible use by application.
- * Hence it mustn't do anything that can't be done twice.
- * Also note that it may be called before the master module is initialized!
- */
-
-GLOBAL(void)
-jpeg_calc_output_dimensions(j_decompress_ptr cinfo)
-/* Do computations that are needed before master selection phase */
-{
-#ifdef IDCT_SCALING_SUPPORTED
-  int ci;
-  jpeg_component_info *compptr;
-#endif
-
-  /* Prevent application from calling me at wrong times */
-  if (cinfo->global_state != DSTATE_READY)
-    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
-
-  /* Compute core output image dimensions and DCT scaling choices. */
-  jpeg_core_output_dimensions(cinfo);
-
-#ifdef IDCT_SCALING_SUPPORTED
-
-  if (!cinfo->master->lossless) {
-    /* In selecting the actual DCT scaling for each component, we try to
-     * scale up the chroma components via IDCT scaling rather than upsampling.
-     * This saves time if the upsampler gets to use 1:1 scaling.
-     * Note this code adapts subsampling ratios which are powers of 2.
-     */
-    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-         ci++, compptr++) {
-      int ssize = cinfo->_min_DCT_scaled_size;
-      while (ssize < DCTSIZE &&
-             ((cinfo->max_h_samp_factor * cinfo->_min_DCT_scaled_size) %
-              (compptr->h_samp_factor * ssize * 2) == 0) &&
-             ((cinfo->max_v_samp_factor * cinfo->_min_DCT_scaled_size) %
-              (compptr->v_samp_factor * ssize * 2) == 0)) {
-        ssize = ssize * 2;
-      }
-#if JPEG_LIB_VERSION >= 70
-      compptr->DCT_h_scaled_size = compptr->DCT_v_scaled_size = ssize;
-#else
-      compptr->DCT_scaled_size = ssize;
-#endif
-    }
-
-    /* Recompute downsampled dimensions of components;
-     * application needs to know these if using raw downsampled data.
-     */
-    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-         ci++, compptr++) {
-      /* Size in samples, after IDCT scaling */
-      compptr->downsampled_width = (JDIMENSION)
-        jdiv_round_up((long)cinfo->image_width *
-                      (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));
-    }
-  } else
-#endif /* IDCT_SCALING_SUPPORTED */
-  {
-    /* Hardwire it to "no scaling" */
-    cinfo->output_width = cinfo->image_width;
-    cinfo->output_height = cinfo->image_height;
-    /* jdinput.c has already initialized DCT_scaled_size to DCTSIZE,
-     * and has computed unscaled downsampled_width and downsampled_height.
-     */
-  }
-
-  /* Report number of components in selected colorspace. */
-  /* Probably this should be in the color conversion module... */
-  switch (cinfo->out_color_space) {
-  case JCS_GRAYSCALE:
-    cinfo->out_color_components = 1;
-    break;
-  case JCS_RGB:
-  case JCS_EXT_RGB:
-  case JCS_EXT_RGBX:
-  case JCS_EXT_BGR:
-  case JCS_EXT_BGRX:
-  case JCS_EXT_XBGR:
-  case JCS_EXT_XRGB:
-  case JCS_EXT_RGBA:
-  case JCS_EXT_BGRA:
-  case JCS_EXT_ABGR:
-  case JCS_EXT_ARGB:
-    cinfo->out_color_components = rgb_pixelsize[cinfo->out_color_space];
-    break;
-  case JCS_YCbCr:
-  case JCS_RGB565:
-    cinfo->out_color_components = 3;
-    break;
-  case JCS_CMYK:
-  case JCS_YCCK:
-    cinfo->out_color_components = 4;
-    break;
-  default:                      /* else must be same colorspace as in file */
-    cinfo->out_color_components = cinfo->num_components;
-    break;
-  }
-  cinfo->output_components = (cinfo->quantize_colors ? 1 :
-                              cinfo->out_color_components);
-
-  /* See if upsampler will want to emit more than one row at a time */
-  if (use_merged_upsample(cinfo))
-    cinfo->rec_outbuf_height = cinfo->max_v_samp_factor;
-  else
-    cinfo->rec_outbuf_height = 1;
-}
-
-
-/*
- * Several decompression processes need to range-limit values to the range
- * 0..MAXJSAMPLE; the input value may fall somewhat outside this range
- * due to noise introduced by quantization, roundoff error, etc.  These
- * processes are inner loops and need to be as fast as possible.  On most
- * machines, particularly CPUs with pipelines or instruction prefetch,
- * a (subscript-check-less) C table lookup
- *              x = sample_range_limit[x];
- * is faster than explicit tests
- *              if (x < 0)  x = 0;
- *              else if (x > MAXJSAMPLE)  x = MAXJSAMPLE;
- * These processes all use a common table prepared by the routine below.
- *
- * For most steps we can mathematically guarantee that the initial value
- * of x is within MAXJSAMPLE+1 of the legal range, so a table running from
- * -(MAXJSAMPLE+1) to 2*MAXJSAMPLE+1 is sufficient.  But for the initial
- * limiting step (just after the IDCT), a wildly out-of-range value is
- * possible if the input data is corrupt.  To avoid any chance of indexing
- * off the end of memory and getting a bad-pointer trap, we perform the
- * post-IDCT limiting thus:
- *              x = range_limit[x & MASK];
- * where MASK is 2 bits wider than legal sample data, ie 10 bits for 8-bit
- * samples.  Under normal circumstances this is more than enough range and
- * a correct output will be generated; with bogus input data the mask will
- * cause wraparound, and we will safely generate a bogus-but-in-range output.
- * For the post-IDCT step, we want to convert the data from signed to unsigned
- * representation by adding CENTERJSAMPLE at the same time that we limit it.
- * So the post-IDCT limiting table ends up looking like this:
- *   CENTERJSAMPLE,CENTERJSAMPLE+1,...,MAXJSAMPLE,
- *   MAXJSAMPLE (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times),
- *   0          (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times),
- *   0,1,...,CENTERJSAMPLE-1
- * Negative inputs select values from the upper half of the table after
- * masking.
- *
- * We can save some space by overlapping the start of the post-IDCT table
- * with the simpler range limiting table.  The post-IDCT table begins at
- * sample_range_limit + CENTERJSAMPLE.
- */
-
-LOCAL(void)
-prepare_range_limit_table(j_decompress_ptr cinfo)
-/* Allocate and fill in the sample_range_limit table */
-{
-  JSAMPLE *table;
-  J12SAMPLE *table12;
-#ifdef D_LOSSLESS_SUPPORTED
-  J16SAMPLE *table16;
-#endif
-  int i;
-
-  if (cinfo->data_precision == 16) {
-#ifdef D_LOSSLESS_SUPPORTED
-    table16 = (J16SAMPLE *)
-      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                  (5 * (MAXJ16SAMPLE + 1) + CENTERJ16SAMPLE) *
-                  sizeof(J16SAMPLE));
-    table16 += (MAXJ16SAMPLE + 1);  /* allow negative subscripts of simple
-                                       table */
-    cinfo->sample_range_limit = (JSAMPLE *)table16;
-    /* First segment of "simple" table: limit[x] = 0 for x < 0 */
-    memset(table16 - (MAXJ16SAMPLE + 1), 0,
-           (MAXJ16SAMPLE + 1) * sizeof(J16SAMPLE));
-    /* Main part of "simple" table: limit[x] = x */
-    for (i = 0; i <= MAXJ16SAMPLE; i++)
-      table16[i] = (J16SAMPLE)i;
-    table16 += CENTERJ16SAMPLE; /* Point to where post-IDCT table starts */
-    /* End of simple table, rest of first half of post-IDCT table */
-    for (i = CENTERJ16SAMPLE; i < 2 * (MAXJ16SAMPLE + 1); i++)
-      table16[i] = MAXJ16SAMPLE;
-    /* Second half of post-IDCT table */
-    memset(table16 + (2 * (MAXJ16SAMPLE + 1)), 0,
-           (2 * (MAXJ16SAMPLE + 1) - CENTERJ16SAMPLE) * sizeof(J16SAMPLE));
-    memcpy(table16 + (4 * (MAXJ16SAMPLE + 1) - CENTERJ16SAMPLE),
-           cinfo->sample_range_limit, CENTERJ16SAMPLE * sizeof(J16SAMPLE));
-#else
-    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-#endif
-  } else if (cinfo->data_precision == 12) {
-    table12 = (J12SAMPLE *)
-      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                  (5 * (MAXJ12SAMPLE + 1) + CENTERJ12SAMPLE) *
-                  sizeof(J12SAMPLE));
-    table12 += (MAXJ12SAMPLE + 1);  /* allow negative subscripts of simple
-                                       table */
-    cinfo->sample_range_limit = (JSAMPLE *)table12;
-    /* First segment of "simple" table: limit[x] = 0 for x < 0 */
-    memset(table12 - (MAXJ12SAMPLE + 1), 0,
-           (MAXJ12SAMPLE + 1) * sizeof(J12SAMPLE));
-    /* Main part of "simple" table: limit[x] = x */
-    for (i = 0; i <= MAXJ12SAMPLE; i++)
-      table12[i] = (J12SAMPLE)i;
-    table12 += CENTERJ12SAMPLE; /* Point to where post-IDCT table starts */
-    /* End of simple table, rest of first half of post-IDCT table */
-    for (i = CENTERJ12SAMPLE; i < 2 * (MAXJ12SAMPLE + 1); i++)
-      table12[i] = MAXJ12SAMPLE;
-    /* Second half of post-IDCT table */
-    memset(table12 + (2 * (MAXJ12SAMPLE + 1)), 0,
-           (2 * (MAXJ12SAMPLE + 1) - CENTERJ12SAMPLE) * sizeof(J12SAMPLE));
-    memcpy(table12 + (4 * (MAXJ12SAMPLE + 1) - CENTERJ12SAMPLE),
-           cinfo->sample_range_limit, CENTERJ12SAMPLE * sizeof(J12SAMPLE));
-  } else {
-    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->sample_range_limit = table;
-    /* First segment of "simple" table: limit[x] = 0 for x < 0 */
-    memset(table - (MAXJSAMPLE + 1), 0, (MAXJSAMPLE + 1) * sizeof(JSAMPLE));
-    /* Main part of "simple" table: limit[x] = x */
-    for (i = 0; i <= MAXJSAMPLE; 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++)
-      table[i] = MAXJSAMPLE;
-    /* Second half of post-IDCT table */
-    memset(table + (2 * (MAXJSAMPLE + 1)), 0,
-           (2 * (MAXJSAMPLE + 1) - CENTERJSAMPLE) * sizeof(JSAMPLE));
-    memcpy(table + (4 * (MAXJSAMPLE + 1) - CENTERJSAMPLE),
-           cinfo->sample_range_limit, CENTERJSAMPLE * sizeof(JSAMPLE));
-  }
-}
-
-
-/*
- * Master selection of decompression modules.
- * This is done once at jpeg_start_decompress time.  We determine
- * which modules will be used and give them appropriate initialization calls.
- * We also initialize the decompressor input side to begin consuming data.
- *
- * Since jpeg_read_header has finished, we know what is in the SOF
- * and (first) SOS markers.  We also have all the application parameter
- * settings.
- */
-
-LOCAL(void)
-master_selection(j_decompress_ptr cinfo)
-{
-  my_master_ptr master = (my_master_ptr)cinfo->master;
-  boolean use_c_buffer;
-  long samplesperrow;
-  JDIMENSION jd_samplesperrow;
-
-  /* Disable IDCT scaling and raw (downsampled) data output in lossless mode.
-   * IDCT scaling is not useful in lossless mode, and it must be disabled in
-   * order to properly calculate the output dimensions.  Raw data output isn't
-   * particularly useful without subsampling and has not been tested in
-   * lossless mode.
-   */
-  if (cinfo->master->lossless) {
-    cinfo->raw_data_out = FALSE;
-    cinfo->scale_num = cinfo->scale_denom = 1;
-  }
-
-  /* Initialize dimensions and other stuff */
-  jpeg_calc_output_dimensions(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)
-    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
-
-  /* Initialize my private state */
-  master->pass_number = 0;
-  master->using_merged_upsample = use_merged_upsample(cinfo);
-
-  /* Color quantizer selection */
-  master->quantizer_1pass = NULL;
-  master->quantizer_2pass = NULL;
-  /* No mode changes if not using buffered-image mode. */
-  if (!cinfo->quantize_colors || !cinfo->buffered_image) {
-    cinfo->enable_1pass_quant = FALSE;
-    cinfo->enable_external_quant = FALSE;
-    cinfo->enable_2pass_quant = FALSE;
-  }
-  if (cinfo->quantize_colors) {
-    if (cinfo->raw_data_out)
-      ERREXIT(cinfo, JERR_NOTIMPL);
-    /* 2-pass quantizer only works in 3-component color space. */
-    if (cinfo->out_color_components != 3 ||
-        cinfo->out_color_space == JCS_RGB565) {
-      cinfo->enable_1pass_quant = TRUE;
-      cinfo->enable_external_quant = FALSE;
-      cinfo->enable_2pass_quant = FALSE;
-      cinfo->colormap = NULL;
-    } else if (cinfo->colormap != NULL) {
-      cinfo->enable_external_quant = TRUE;
-    } else if (cinfo->two_pass_quantize) {
-      cinfo->enable_2pass_quant = TRUE;
-    } else {
-      cinfo->enable_1pass_quant = TRUE;
-    }
-
-    if (cinfo->enable_1pass_quant) {
-#ifdef QUANT_1PASS_SUPPORTED
-      if (cinfo->data_precision == 16)
-        ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-      else if (cinfo->data_precision == 12)
-        j12init_1pass_quantizer(cinfo);
-      else
-        jinit_1pass_quantizer(cinfo);
-      master->quantizer_1pass = cinfo->cquantize;
-#else
-      ERREXIT(cinfo, JERR_NOT_COMPILED);
-#endif
-    }
-
-    /* We use the 2-pass code to map to external colormaps. */
-    if (cinfo->enable_2pass_quant || cinfo->enable_external_quant) {
-#ifdef QUANT_2PASS_SUPPORTED
-      if (cinfo->data_precision == 16)
-        ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-      else if (cinfo->data_precision == 12)
-        j12init_2pass_quantizer(cinfo);
-      else
-        jinit_2pass_quantizer(cinfo);
-      master->quantizer_2pass = cinfo->cquantize;
-#else
-      ERREXIT(cinfo, JERR_NOT_COMPILED);
-#endif
-    }
-    /* If both quantizers are initialized, the 2-pass one is left active;
-     * this is necessary for starting with quantization to an external map.
-     */
-  }
-
-  /* Post-processing: in particular, color conversion first */
-  if (!cinfo->raw_data_out) {
-    if (master->using_merged_upsample) {
-#ifdef UPSAMPLE_MERGING_SUPPORTED
-      if (cinfo->data_precision == 16)
-        ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-      else if (cinfo->data_precision == 12)
-        j12init_merged_upsampler(cinfo); /* does color conversion too */
-      else
-        jinit_merged_upsampler(cinfo); /* does color conversion too */
-#else
-      ERREXIT(cinfo, JERR_NOT_COMPILED);
-#endif
-    } else {
-      if (cinfo->data_precision == 16) {
-#ifdef D_LOSSLESS_SUPPORTED
-        j16init_color_deconverter(cinfo);
-        j16init_upsampler(cinfo);
-#else
-        ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-#endif
-      } else if (cinfo->data_precision == 12) {
-        j12init_color_deconverter(cinfo);
-        j12init_upsampler(cinfo);
-      } else {
-        jinit_color_deconverter(cinfo);
-        jinit_upsampler(cinfo);
-      }
-    }
-    if (cinfo->data_precision == 16)
-#ifdef D_LOSSLESS_SUPPORTED
-      j16init_d_post_controller(cinfo, cinfo->enable_2pass_quant);
-#else
-      ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-#endif
-    else if (cinfo->data_precision == 12)
-      j12init_d_post_controller(cinfo, cinfo->enable_2pass_quant);
-    else
-      jinit_d_post_controller(cinfo, cinfo->enable_2pass_quant);
-  }
-
-  if (cinfo->master->lossless) {
-#ifdef D_LOSSLESS_SUPPORTED
-    /* Prediction, sample undifferencing, point transform, and sample size
-     * scaling
-     */
-    if (cinfo->data_precision == 16)
-      j16init_lossless_decompressor(cinfo);
-    else if (cinfo->data_precision == 12)
-      j12init_lossless_decompressor(cinfo);
-    else
-      jinit_lossless_decompressor(cinfo);
-    /* Entropy decoding: either Huffman or arithmetic coding. */
-    if (cinfo->arith_code) {
-      ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
-    } else {
-      jinit_lhuff_decoder(cinfo);
-    }
-
-    /* Initialize principal buffer controllers. */
-    use_c_buffer = cinfo->inputctl->has_multiple_scans ||
-                   cinfo->buffered_image;
-    if (cinfo->data_precision == 16)
-      j16init_d_diff_controller(cinfo, use_c_buffer);
-    else if (cinfo->data_precision == 12)
-      j12init_d_diff_controller(cinfo, use_c_buffer);
-    else
-      jinit_d_diff_controller(cinfo, use_c_buffer);
-#else
-    ERREXIT(cinfo, JERR_NOT_COMPILED);
-#endif
-  } else {
-    if (cinfo->data_precision == 16)
-      ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-    /* Inverse DCT */
-    if (cinfo->data_precision == 12)
-      j12init_inverse_dct(cinfo);
-    else
-      jinit_inverse_dct(cinfo);
-    /* Entropy decoding: either Huffman or arithmetic coding. */
-    if (cinfo->arith_code) {
-#ifdef D_ARITH_CODING_SUPPORTED
-      jinit_arith_decoder(cinfo);
-#else
-      ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
-#endif
-    } else {
-      if (cinfo->progressive_mode) {
-#ifdef D_PROGRESSIVE_SUPPORTED
-        jinit_phuff_decoder(cinfo);
-#else
-        ERREXIT(cinfo, JERR_NOT_COMPILED);
-#endif
-      } else
-        jinit_huff_decoder(cinfo);
-    }
-
-    /* Initialize principal buffer controllers. */
-    use_c_buffer = cinfo->inputctl->has_multiple_scans ||
-                   cinfo->buffered_image;
-    if (cinfo->data_precision == 12)
-      j12init_d_coef_controller(cinfo, use_c_buffer);
-    else
-      jinit_d_coef_controller(cinfo, use_c_buffer);
-  }
-
-  if (!cinfo->raw_data_out) {
-    if (cinfo->data_precision == 16)
-#ifdef D_LOSSLESS_SUPPORTED
-      j16init_d_main_controller(cinfo,
-                                FALSE /* never need full buffer here */);
-#else
-      ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-#endif
-    else if (cinfo->data_precision == 12)
-      j12init_d_main_controller(cinfo,
-                                FALSE /* never need full buffer here */);
-    else
-      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);
-
-  /* Initialize input side of decompressor to consume first scan. */
-  (*cinfo->inputctl->start_input_pass) (cinfo);
-
-  /* Set the first and last iMCU columns to decompress from single-scan images.
-   * By default, decompress all of the iMCU columns.
-   */
-  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 &&
-      cinfo->inputctl->has_multiple_scans) {
-    int nscans;
-    /* Estimate number of scans to set pass_limit. */
-    if (cinfo->progressive_mode) {
-      /* Arbitrarily estimate 2 interleaved DC scans + 3 AC scans/component. */
-      nscans = 2 + 3 * cinfo->num_components;
-    } else {
-      /* For a nonprogressive multiscan file, estimate 1 scan per component. */
-      nscans = cinfo->num_components;
-    }
-    cinfo->progress->pass_counter = 0L;
-    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 */
-    master->pass_number++;
-  }
-#endif /* D_MULTISCAN_FILES_SUPPORTED */
-}
-
-
-/*
- * Per-pass setup.
- * This is called at the beginning of each output pass.  We determine which
- * modules will be active during this pass and give them appropriate
- * start_pass calls.  We also set is_dummy_pass to indicate whether this
- * is a "real" output pass or a dummy pass for color quantization.
- * (In the latter case, jdapistd.c will crank the pass to completion.)
- */
-
-METHODDEF(void)
-prepare_for_output_pass(j_decompress_ptr cinfo)
-{
-  my_master_ptr master = (my_master_ptr)cinfo->master;
-
-  if (master->pub.is_dummy_pass) {
-#ifdef QUANT_2PASS_SUPPORTED
-    /* Final pass of 2-pass quantization */
-    master->pub.is_dummy_pass = FALSE;
-    (*cinfo->cquantize->start_pass) (cinfo, FALSE);
-    (*cinfo->post->start_pass) (cinfo, JBUF_CRANK_DEST);
-    (*cinfo->main->start_pass) (cinfo, JBUF_CRANK_DEST);
-#else
-    ERREXIT(cinfo, JERR_NOT_COMPILED);
-#endif /* QUANT_2PASS_SUPPORTED */
-  } else {
-    if (cinfo->quantize_colors && cinfo->colormap == NULL) {
-      /* Select new quantization method */
-      if (cinfo->two_pass_quantize && cinfo->enable_2pass_quant) {
-        cinfo->cquantize = master->quantizer_2pass;
-        master->pub.is_dummy_pass = TRUE;
-      } else if (cinfo->enable_1pass_quant) {
-        cinfo->cquantize = master->quantizer_1pass;
-      } else {
-        ERREXIT(cinfo, JERR_MODE_CHANGE);
-      }
-    }
-    (*cinfo->idct->start_pass) (cinfo);
-    (*cinfo->coef->start_output_pass) (cinfo);
-    if (!cinfo->raw_data_out) {
-      if (!master->using_merged_upsample)
-        (*cinfo->cconvert->start_pass) (cinfo);
-      (*cinfo->upsample->start_pass) (cinfo);
-      if (cinfo->quantize_colors)
-        (*cinfo->cquantize->start_pass) (cinfo, master->pub.is_dummy_pass);
-      (*cinfo->post->start_pass) (cinfo,
-            (master->pub.is_dummy_pass ? JBUF_SAVE_AND_PASS : JBUF_PASS_THRU));
-      (*cinfo->main->start_pass) (cinfo, JBUF_PASS_THRU);
-    }
-  }
-
-  /* Set up progress monitor's pass info if present */
-  if (cinfo->progress != NULL) {
-    cinfo->progress->completed_passes = master->pass_number;
-    cinfo->progress->total_passes = master->pass_number +
-                                    (master->pub.is_dummy_pass ? 2 : 1);
-    /* 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) {
-      cinfo->progress->total_passes += (cinfo->enable_2pass_quant ? 2 : 1);
-    }
-  }
-}
-
-
-/*
- * Finish up at end of an output pass.
- */
-
-METHODDEF(void)
-finish_output_pass(j_decompress_ptr cinfo)
-{
-  my_master_ptr master = (my_master_ptr)cinfo->master;
-
-  if (cinfo->quantize_colors)
-    (*cinfo->cquantize->finish_pass) (cinfo);
-  master->pass_number++;
-}
-
-
-#ifdef D_MULTISCAN_FILES_SUPPORTED
-
-/*
- * Switch to a new external colormap between output passes.
- */
-
-GLOBAL(void)
-jpeg_new_colormap(j_decompress_ptr cinfo)
-{
-  my_master_ptr master = (my_master_ptr)cinfo->master;
-
-  /* Prevent application from calling me at wrong times */
-  if (cinfo->global_state != DSTATE_BUFIMAGE)
-    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
-
-  if (cinfo->quantize_colors && cinfo->enable_external_quant &&
-      cinfo->colormap != NULL) {
-    /* Select 2-pass quantizer for external colormap use */
-    cinfo->cquantize = master->quantizer_2pass;
-    /* Notify quantizer of colormap change */
-    (*cinfo->cquantize->new_color_map) (cinfo);
-    master->pub.is_dummy_pass = FALSE; /* just in case */
-  } else
-    ERREXIT(cinfo, JERR_MODE_CHANGE);
-}
-
-#endif /* D_MULTISCAN_FILES_SUPPORTED */
-
-
-/*
- * Initialize master decompression control and select active modules.
- * This is performed at the start of jpeg_start_decompress.
- */
-
-GLOBAL(void)
-jinit_master_decompress(j_decompress_ptr cinfo)
-{
-  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;
-
-  master->pub.is_dummy_pass = FALSE;
-  master->pub.jinit_upsampler_no_alloc = FALSE;
-
-  master_selection(cinfo);
-}
@@ -1,28 +0,0 @@
-/*
- * jdmaster.h
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1991-1995, Thomas G. Lane.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains the master control structure for the JPEG decompressor.
- */
-
-/* Private state */
-
-typedef struct {
-  struct jpeg_decomp_master pub; /* public fields */
-
-  int pass_number;              /* # of passes completed */
-
-  boolean using_merged_upsample; /* TRUE if using merged upsample/cconvert */
-
-  /* Saved references to initialized quantizer modules,
-   * in case we need to switch modes.
-   */
-  struct jpeg_color_quantizer *quantizer_1pass;
-  struct jpeg_color_quantizer *quantizer_2pass;
-} my_decomp_master;
-
-typedef my_decomp_master *my_master_ptr;
@@ -1,594 +0,0 @@
-/*
- * jdmerge.c
- *
- * This file was part of the Independent JPEG Group's software:
- * 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, 2022, D. R. Commander.
- * Copyright (C) 2013, Linaro Limited.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains code for merged upsampling/color conversion.
- *
- * This file combines functions from jdsample.c and jdcolor.c;
- * read those files first to understand what's going on.
- *
- * When the chroma components are to be upsampled by simple replication
- * (ie, box filtering), we can save some work in color conversion by
- * calculating all the output pixels corresponding to a pair of chroma
- * samples at one time.  In the conversion equations
- *      R = Y           + K1 * Cr
- *      G = Y + K2 * Cb + K3 * Cr
- *      B = Y + K4 * Cb
- * only the Y term varies among the group of pixels corresponding to a pair
- * of chroma samples, so the rest of the terms can be calculated just once.
- * At typical sampling ratios, this eliminates half or three-quarters of the
- * multiplications needed for color conversion.
- *
- * This file currently provides implementations for the following cases:
- *      YCbCr => RGB color conversion only.
- *      Sampling ratios of 2h1v or 2h2v.
- *      No scaling needed at upsample time.
- *      Corner-aligned (non-CCIR601) sampling alignment.
- * Other special cases could be added, but in most applications these are
- * the only common cases.  (For uncommon cases we fall back on the more
- * general code in jdsample.c and jdcolor.c.)
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jdmerge.h"
-#include "jsimd.h"
-
-#ifdef UPSAMPLE_MERGING_SUPPORTED
-
-
-#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))
-
-
-/* Include inline routines for colorspace extensions */
-
-#include "jdmrgext.c"
-#undef RGB_RED
-#undef RGB_GREEN
-#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
-#include "jdmrgext.c"
-#undef RGB_RED
-#undef RGB_GREEN
-#undef RGB_BLUE
-#undef RGB_PIXELSIZE
-#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
-#include "jdmrgext.c"
-#undef RGB_RED
-#undef RGB_GREEN
-#undef RGB_BLUE
-#undef RGB_ALPHA
-#undef RGB_PIXELSIZE
-#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
-#include "jdmrgext.c"
-#undef RGB_RED
-#undef RGB_GREEN
-#undef RGB_BLUE
-#undef RGB_PIXELSIZE
-#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
-#include "jdmrgext.c"
-#undef RGB_RED
-#undef RGB_GREEN
-#undef RGB_BLUE
-#undef RGB_ALPHA
-#undef RGB_PIXELSIZE
-#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
-#include "jdmrgext.c"
-#undef RGB_RED
-#undef RGB_GREEN
-#undef RGB_BLUE
-#undef RGB_ALPHA
-#undef RGB_PIXELSIZE
-#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
-#include "jdmrgext.c"
-#undef RGB_RED
-#undef RGB_GREEN
-#undef RGB_BLUE
-#undef RGB_ALPHA
-#undef RGB_PIXELSIZE
-#undef h2v1_merged_upsample_internal
-#undef h2v2_merged_upsample_internal
-
-
-/*
- * Initialize tables for YCC->RGB colorspace conversion.
- * This is taken directly from jdcolor.c; see that file for more info.
- */
-
-LOCAL(void)
-build_ycc_rgb_table(j_decompress_ptr cinfo)
-{
-  my_merged_upsample_ptr upsample = (my_merged_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));
-  upsample->Cb_b_tab = (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));
-  upsample->Cb_g_tab = (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 */
-    /* The Cb or Cr value we are thinking of is x = i - _CENTERJSAMPLE */
-    /* Cr=>R value is nearest int to 1.40200 * x */
-    upsample->Cr_r_tab[i] = (int)
-                    RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
-    /* Cb=>B value is nearest int to 1.77200 * x */
-    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;
-    /* 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;
-  }
-}
-
-
-/*
- * Initialize for an upsampling pass.
- */
-
-METHODDEF(void)
-start_pass_merged_upsample(j_decompress_ptr cinfo)
-{
-  my_merged_upsample_ptr upsample = (my_merged_upsample_ptr)cinfo->upsample;
-
-  /* Mark the spare buffer empty */
-  upsample->spare_full = FALSE;
-  /* Initialize total-height counter for detecting bottom of image */
-  upsample->rows_to_go = cinfo->output_height;
-}
-
-
-/*
- * Control routine to do upsampling (and color conversion).
- *
- * The control routine just handles the row buffering considerations.
- */
-
-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)
-/* 2:1 vertical sampling case: may need a spare row. */
-{
-  my_merged_upsample_ptr upsample = (my_merged_upsample_ptr)cinfo->upsample;
-  _JSAMPROW work_ptrs[2];
-  JDIMENSION num_rows;          /* number of rows returned to caller */
-
-  if (upsample->spare_full) {
-    /* If we have a spare row saved from a previous cycle, just return it. */
-    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);
-    num_rows = 1;
-    upsample->spare_full = FALSE;
-  } else {
-    /* Figure number of rows to return to caller. */
-    num_rows = 2;
-    /* Not more than the distance to the end of the image. */
-    if (num_rows > upsample->rows_to_go)
-      num_rows = upsample->rows_to_go;
-    /* And not more than what the client can accept: */
-    out_rows_avail -= *out_row_ctr;
-    if (num_rows > out_rows_avail)
-      num_rows = out_rows_avail;
-    /* Create output pointer array for upsampler. */
-    work_ptrs[0] = output_buf[*out_row_ctr];
-    if (num_rows > 1) {
-      work_ptrs[1] = output_buf[*out_row_ctr + 1];
-    } else {
-      work_ptrs[1] = upsample->spare_row;
-      upsample->spare_full = TRUE;
-    }
-    /* Now do the upsampling. */
-    (*upsample->upmethod) (cinfo, input_buf, *in_row_group_ctr, work_ptrs);
-  }
-
-  /* Adjust counts */
-  *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)
-    (*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)
-/* 1:1 vertical sampling case: much easier, never need a spare row. */
-{
-  my_merged_upsample_ptr upsample = (my_merged_upsample_ptr)cinfo->upsample;
-
-  /* Just do the upsampling. */
-  (*upsample->upmethod) (cinfo, input_buf, *in_row_group_ctr,
-                         output_buf + *out_row_ctr);
-  /* Adjust counts */
-  (*out_row_ctr)++;
-  (*in_row_group_ctr)++;
-}
-
-
-/*
- * These are the routines invoked by the control routines to do
- * the actual upsampling/conversion.  One row group is processed per call.
- *
- * Note: since we may be writing directly into application-supplied buffers,
- * we have to be honest about the output width; we can't assume the buffer
- * has been rounded up to an even width.
- */
-
-
-/*
- * Upsample and color convert for the case of 2:1 horizontal and 1:1 vertical.
- */
-
-METHODDEF(void)
-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;
-  }
-}
-
-
-/*
- * Upsample and color convert for the case of 2:1 horizontal and 2:1 vertical.
- */
-
-METHODDEF(void)
-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;
-  }
-}
-
-
-/*
- * 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_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 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))
-#define DITHER_565_G(g, dither)  ((g) + (((dither) & 0xFF) >> 1))
-#define DITHER_565_B(b, dither)  ((b) + ((dither) & 0xFF))
-
-
-/* Declarations for ordered dithering
- *
- * We use a 4x4 ordered dither array packed into 32 bits.  This array is
- * sufficient for dithering RGB888 to RGB565.
- */
-
-#define DITHER_MASK       0x3
-#define DITHER_ROTATE(x)  ((((x) & 0xFF) << 24) | (((x) >> 8) & 0x00FFFFFF))
-static const JLONG dither_matrix[4] = {
-  0x0008020A,
-  0x0C040E06,
-  0x030B0109,
-  0x0F070D05
-};
-
-
-/* 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
-#include "jdmrg565.c"
-#undef PACK_SHORT_565
-#undef PACK_TWO_PIXELS
-#undef WRITE_TWO_PIXELS
-#undef h2v1_merged_upsample_565_internal
-#undef h2v1_merged_upsample_565D_internal
-#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
-#include "jdmrg565.c"
-#undef PACK_SHORT_565
-#undef PACK_TWO_PIXELS
-#undef WRITE_TWO_PIXELS
-#undef h2v1_merged_upsample_565_internal
-#undef h2v1_merged_upsample_565D_internal
-#undef h2v2_merged_upsample_565_internal
-#undef h2v2_merged_upsample_565D_internal
-
-
-static INLINE boolean is_big_endian(void)
-{
-  int test_value = 1;
-  if (*(char *)&test_value != 1)
-    return TRUE;
-  return FALSE;
-}
-
-
-METHODDEF(void)
-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,
-                                output_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)
-{
-  if (is_big_endian())
-    h2v1_merged_upsample_565D_be(cinfo, input_buf, in_row_group_ctr,
-                                 output_buf);
-  else
-    h2v1_merged_upsample_565D_le(cinfo, input_buf, in_row_group_ctr,
-                                 output_buf);
-}
-
-
-METHODDEF(void)
-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,
-                                output_buf);
-  else
-    h2v2_merged_upsample_565_le(cinfo, input_buf, in_row_group_ctr,
-                                output_buf);
-}
-
-
-METHODDEF(void)
-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,
-                                 output_buf);
-  else
-    h2v2_merged_upsample_565D_le(cinfo, input_buf, in_row_group_ctr,
-                                 output_buf);
-}
-
-
-/*
- * Module initialization routine for merged upsampling/color conversion.
- *
- * NB: this is called under the conditions determined by use_merged_upsample()
- * in jdmaster.c.  That routine MUST correspond to the actual capabilities
- * of this module; no safety checks are made here.
- */
-
-GLOBAL(void)
-_jinit_merged_upsampler(j_decompress_ptr cinfo)
-{
-  my_merged_upsample_ptr upsample;
-
-  if (cinfo->data_precision != BITS_IN_JSAMPLE)
-    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-
-  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->pub.start_pass = start_pass_merged_upsample;
-  upsample->pub.need_context_rows = FALSE;
-
-  upsample->out_row_width = cinfo->output_width * cinfo->out_color_components;
-
-  if (cinfo->max_v_samp_factor == 2) {
-    upsample->pub._upsample = merged_2v_upsample;
-#ifdef WITH_SIMD
-    if (jsimd_can_h2v2_merged_upsample())
-      upsample->upmethod = jsimd_h2v2_merged_upsample;
-    else
-#endif
-      upsample->upmethod = h2v2_merged_upsample;
-    if (cinfo->out_color_space == JCS_RGB565) {
-      if (cinfo->dither_mode != JDITHER_NONE) {
-        upsample->upmethod = h2v2_merged_upsample_565D;
-      } else {
-        upsample->upmethod = h2v2_merged_upsample_565;
-      }
-    }
-    /* 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)));
-  } else {
-    upsample->pub._upsample = merged_1v_upsample;
-#ifdef WITH_SIMD
-    if (jsimd_can_h2v1_merged_upsample())
-      upsample->upmethod = jsimd_h2v1_merged_upsample;
-    else
-#endif
-      upsample->upmethod = h2v1_merged_upsample;
-    if (cinfo->out_color_space == JCS_RGB565) {
-      if (cinfo->dither_mode != JDITHER_NONE) {
-        upsample->upmethod = h2v1_merged_upsample_565D;
-      } else {
-        upsample->upmethod = h2v1_merged_upsample_565;
-      }
-    }
-    /* No spare row needed */
-    upsample->spare_row = NULL;
-  }
-
-  build_ycc_rgb_table(cinfo);
-}
-
-#endif /* UPSAMPLE_MERGING_SUPPORTED */
@@ -1,48 +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, 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- */
-
-#define JPEG_INTERNALS
-#include "jpeglib.h"
-#include "jsamplecomp.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 */
@@ -1,355 +0,0 @@
-/*
- * jdmrg565.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1994-1996, Thomas G. Lane.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2013, Linaro Limited.
- * Copyright (C) 2014-2015, 2018, 2020, 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains code for merged upsampling/color conversion.
- */
-
-
-INLINE
-LOCAL(void)
-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;
-  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 = (_JSAMPLE *)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
-
-  inptr0 = input_buf[0][in_row_group_ctr];
-  inptr1 = input_buf[1][in_row_group_ctr];
-  inptr2 = input_buf[2][in_row_group_ctr];
-  outptr = output_buf[0];
-
-  /* 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++;
-    cred = Crrtab[cr];
-    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
-    cblue = Cbbtab[cb];
-
-    /* Fetch 2 Y values and emit 2 pixels */
-    y  = *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++;
-    r = range_limit[y + cred];
-    g = range_limit[y + cgreen];
-    b = range_limit[y + cblue];
-    rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
-
-    WRITE_TWO_PIXELS(outptr, rgb);
-    outptr += 4;
-  }
-
-  /* If image width is odd, do the last output column separately */
-  if (cinfo->output_width & 1) {
-    cb = *inptr1;
-    cr = *inptr2;
-    cred = Crrtab[cr];
-    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
-    cblue = Cbbtab[cb];
-    y  = *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;
-  }
-}
-
-
-INLINE
-LOCAL(void)
-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;
-  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 = (_JSAMPLE *)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;
-  SHIFT_TEMPS
-
-  inptr0 = input_buf[0][in_row_group_ctr];
-  inptr1 = input_buf[1][in_row_group_ctr];
-  inptr2 = input_buf[2][in_row_group_ctr];
-  outptr = output_buf[0];
-
-  /* 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++;
-    cred = Crrtab[cr];
-    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
-    cblue = Cbbtab[cb];
-
-    /* Fetch 2 Y values and emit 2 pixels */
-    y  = *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++;
-    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_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
-
-    WRITE_TWO_PIXELS(outptr, rgb);
-    outptr += 4;
-  }
-
-  /* If image width is odd, do the last output column separately */
-  if (cinfo->output_width & 1) {
-    cb = *inptr1;
-    cr = *inptr2;
-    cred = Crrtab[cr];
-    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
-    cblue = Cbbtab[cb];
-    y  = *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;
-  }
-}
-
-
-INLINE
-LOCAL(void)
-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;
-  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 = (_JSAMPLE *)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
-
-  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];
-  outptr1 = output_buf[1];
-
-  /* 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++;
-    cred = Crrtab[cr];
-    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
-    cblue = Cbbtab[cb];
-
-    /* Fetch 4 Y values and emit 4 pixels */
-    y  = *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++;
-    r = range_limit[y + cred];
-    g = range_limit[y + cgreen];
-    b = range_limit[y + cblue];
-    rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
-
-    WRITE_TWO_PIXELS(outptr0, rgb);
-    outptr0 += 4;
-
-    y  = *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++;
-    r = range_limit[y + cred];
-    g = range_limit[y + cgreen];
-    b = range_limit[y + cblue];
-    rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
-
-    WRITE_TWO_PIXELS(outptr1, rgb);
-    outptr1 += 4;
-  }
-
-  /* If image width is odd, do the last output column separately */
-  if (cinfo->output_width & 1) {
-    cb = *inptr1;
-    cr = *inptr2;
-    cred = Crrtab[cr];
-    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
-    cblue = Cbbtab[cb];
-
-    y  = *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;
-
-    y  = *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;
-  }
-}
-
-
-INLINE
-LOCAL(void)
-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;
-  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 = (_JSAMPLE *)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];
-  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];
-  inptr1 = input_buf[1][in_row_group_ctr];
-  inptr2 = input_buf[2][in_row_group_ctr];
-  outptr0 = output_buf[0];
-  outptr1 = output_buf[1];
-
-  /* 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++;
-    cred = Crrtab[cr];
-    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
-    cblue = Cbbtab[cb];
-
-    /* Fetch 4 Y values and emit 4 pixels */
-    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);
-    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);
-    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);
-    rgb = PACK_SHORT_565(r, g, b);
-
-    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);
-    rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
-
-    WRITE_TWO_PIXELS(outptr1, rgb);
-    outptr1 += 4;
-  }
-
-  /* If image width is odd, do the last output column separately */
-  if (cinfo->output_width & 1) {
-    cb = *inptr1;
-    cr = *inptr2;
-    cred = Crrtab[cr];
-    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
-    cblue = Cbbtab[cb];
-
-    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)];
-    rgb = PACK_SHORT_565(r, g, b);
-    *(INT16 *)outptr0 = (INT16)rgb;
-
-    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)];
-    rgb = PACK_SHORT_565(r, g, b);
-    *(INT16 *)outptr1 = (INT16)rgb;
-  }
-}
@@ -1,184 +0,0 @@
-/*
- * jdmrgext.c
- *
- * 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, 2022-2023, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains code for merged upsampling/color conversion.
- */
-
-
-/* This file is included by jdmerge.c */
-
-
-/*
- * Upsample and color convert for the case of 2:1 horizontal and 1:1 vertical.
- */
-
-INLINE
-LOCAL(void)
-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;
-  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 = (_JSAMPLE *)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];
-  inptr1 = input_buf[1][in_row_group_ctr];
-  inptr2 = input_buf[2][in_row_group_ctr];
-  outptr = output_buf[0];
-  /* 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++;
-    cred = Crrtab[cr];
-    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
-    cblue = Cbbtab[cb];
-    /* Fetch 2 Y values and emit 2 pixels */
-    y  = *inptr0++;
-    outptr[RGB_RED] =   range_limit[y + cred];
-    outptr[RGB_GREEN] = range_limit[y + cgreen];
-    outptr[RGB_BLUE] =  range_limit[y + cblue];
-#ifdef RGB_ALPHA
-    outptr[RGB_ALPHA] = _MAXJSAMPLE;
-#endif
-    outptr += RGB_PIXELSIZE;
-    y  = *inptr0++;
-    outptr[RGB_RED] =   range_limit[y + cred];
-    outptr[RGB_GREEN] = range_limit[y + cgreen];
-    outptr[RGB_BLUE] =  range_limit[y + cblue];
-#ifdef RGB_ALPHA
-    outptr[RGB_ALPHA] = _MAXJSAMPLE;
-#endif
-    outptr += RGB_PIXELSIZE;
-  }
-  /* If image width is odd, do the last output column separately */
-  if (cinfo->output_width & 1) {
-    cb = *inptr1;
-    cr = *inptr2;
-    cred = Crrtab[cr];
-    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
-    cblue = Cbbtab[cb];
-    y  = *inptr0;
-    outptr[RGB_RED] =   range_limit[y + cred];
-    outptr[RGB_GREEN] = range_limit[y + cgreen];
-    outptr[RGB_BLUE] =  range_limit[y + cblue];
-#ifdef RGB_ALPHA
-    outptr[RGB_ALPHA] = _MAXJSAMPLE;
-#endif
-  }
-}
-
-
-/*
- * Upsample and color convert for the case of 2:1 horizontal and 2:1 vertical.
- */
-
-INLINE
-LOCAL(void)
-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;
-  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 = (_JSAMPLE *)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];
-  inptr1 = input_buf[1][in_row_group_ctr];
-  inptr2 = input_buf[2][in_row_group_ctr];
-  outptr0 = output_buf[0];
-  outptr1 = output_buf[1];
-  /* 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++;
-    cred = Crrtab[cr];
-    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
-    cblue = Cbbtab[cb];
-    /* Fetch 4 Y values and emit 4 pixels */
-    y  = *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] = _MAXJSAMPLE;
-#endif
-    outptr0 += RGB_PIXELSIZE;
-    y  = *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] = _MAXJSAMPLE;
-#endif
-    outptr0 += RGB_PIXELSIZE;
-    y  = *inptr01++;
-    outptr1[RGB_RED] =   range_limit[y + cred];
-    outptr1[RGB_GREEN] = range_limit[y + cgreen];
-    outptr1[RGB_BLUE] =  range_limit[y + cblue];
-#ifdef RGB_ALPHA
-    outptr1[RGB_ALPHA] = _MAXJSAMPLE;
-#endif
-    outptr1 += RGB_PIXELSIZE;
-    y  = *inptr01++;
-    outptr1[RGB_RED] =   range_limit[y + cred];
-    outptr1[RGB_GREEN] = range_limit[y + cgreen];
-    outptr1[RGB_BLUE] =  range_limit[y + cblue];
-#ifdef RGB_ALPHA
-    outptr1[RGB_ALPHA] = _MAXJSAMPLE;
-#endif
-    outptr1 += RGB_PIXELSIZE;
-  }
-  /* If image width is odd, do the last output column separately */
-  if (cinfo->output_width & 1) {
-    cb = *inptr1;
-    cr = *inptr2;
-    cred = Crrtab[cr];
-    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
-    cblue = Cbbtab[cb];
-    y  = *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] = _MAXJSAMPLE;
-#endif
-    y  = *inptr01;
-    outptr1[RGB_RED] =   range_limit[y + cred];
-    outptr1[RGB_GREEN] = range_limit[y + cgreen];
-    outptr1[RGB_BLUE] =  range_limit[y + cblue];
-#ifdef RGB_ALPHA
-    outptr1[RGB_ALPHA] = _MAXJSAMPLE;
-#endif
-  }
-}
@@ -1,681 +0,0 @@
-/*
- * jdphuff.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1995-1997, Thomas G. Lane.
- * Lossless JPEG Modifications:
- * Copyright (C) 1999, Ken Murchison.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2015-2016, 2018-2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains Huffman entropy decoding routines for progressive JPEG.
- *
- * Much of the complexity here has to do with supporting input suspension.
- * If the data source module demands suspension, we want to be able to back
- * 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 jd*huff.c */
-#include <limits.h>
-
-
-#ifdef D_PROGRESSIVE_SUPPORTED
-
-/*
- * Expanded entropy decoder object for progressive Huffman decoding.
- *
- * The savable_state subrecord contains fields that change within an MCU,
- * but must not be updated permanently until we complete the MCU.
- */
-
-typedef struct {
-  unsigned int EOBRUN;                  /* remaining EOBs in EOBRUN */
-  int last_dc_val[MAX_COMPS_IN_SCAN];   /* last DC coef for each component */
-} savable_state;
-
-typedef struct {
-  struct jpeg_entropy_decoder pub; /* public fields */
-
-  /* These fields are loaded into local variables at start of each MCU.
-   * In case of suspension, we exit WITHOUT updating them.
-   */
-  bitread_perm_state bitstate;  /* Bit buffer at start of MCU */
-  savable_state saved;          /* Other state at start of MCU */
-
-  /* These fields are NOT loaded into local working state. */
-  unsigned int restarts_to_go;  /* MCUs left in this restart interval */
-
-  /* Pointers to derived tables (these workspaces have image lifespan) */
-  d_derived_tbl *derived_tbls[NUM_HUFF_TBLS];
-
-  d_derived_tbl *ac_derived_tbl; /* active table during an AC scan */
-} phuff_entropy_decoder;
-
-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,
-                                        JBLOCKROW *MCU_data);
-METHODDEF(boolean) decode_mcu_AC_refine(j_decompress_ptr cinfo,
-                                        JBLOCKROW *MCU_data);
-
-
-/*
- * Initialize for a Huffman-compressed scan.
- */
-
-METHODDEF(void)
-start_pass_phuff_decoder(j_decompress_ptr cinfo)
-{
-  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;
-  jpeg_component_info *compptr;
-
-  is_DC_band = (cinfo->Ss == 0);
-
-  /* Validate scan parameters */
-  bad = FALSE;
-  if (is_DC_band) {
-    if (cinfo->Se != 0)
-      bad = TRUE;
-  } else {
-    /* need not check Ss/Se < 0 since they came from unsigned bytes */
-    if (cinfo->Ss > cinfo->Se || cinfo->Se >= DCTSIZE2)
-      bad = TRUE;
-    /* AC scans may have only one component */
-    if (cinfo->comps_in_scan != 1)
-      bad = TRUE;
-  }
-  if (cinfo->Ah != 0) {
-    /* Successive approximation refinement scan: must have Al = Ah-1. */
-    if (cinfo->Al != cinfo->Ah - 1)
-      bad = TRUE;
-  }
-  if (cinfo->Al > 13)           /* need not check for < 0 */
-    bad = TRUE;
-  /* Arguably the maximum Al value should be less than 13 for 8-bit precision,
-   * but the spec doesn't say so, and we try to be liberal about what we
-   * accept.  Note: large Al values could result in out-of-range DC
-   * coefficients during early scans, leading to bizarre displays due to
-   * overflows in the IDCT math.  But we won't crash.
-   */
-  if (bad)
-    ERREXIT4(cinfo, JERR_BAD_PROGRESSION,
-             cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al);
-  /* Update progression status, and verify that scan order is legal.
-   * Note that inter-scan inconsistencies are treated as warnings
-   * not fatal errors ... not clear if this is right way to behave.
-   */
-  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];
-    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)
-        WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, coefi);
-      coef_bit_ptr[coefi] = cinfo->Al;
-    }
-  }
-
-  /* Select MCU decoding routine */
-  if (cinfo->Ah == 0) {
-    if (is_DC_band)
-      entropy->pub.decode_mcu = decode_mcu_DC_first;
-    else
-      entropy->pub.decode_mcu = decode_mcu_AC_first;
-  } else {
-    if (is_DC_band)
-      entropy->pub.decode_mcu = decode_mcu_DC_refine;
-    else
-      entropy->pub.decode_mcu = decode_mcu_AC_refine;
-  }
-
-  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
-    compptr = cinfo->cur_comp_info[ci];
-    /* Make sure requested tables are present, and compute derived tables.
-     * We may build same derived table more than once, but it's not expensive.
-     */
-    if (is_DC_band) {
-      if (cinfo->Ah == 0) {     /* DC refinement needs no table */
-        tbl = compptr->dc_tbl_no;
-        pdtbl = (d_derived_tbl **)(entropy->derived_tbls) + tbl;
-        jpeg_make_d_derived_tbl(cinfo, TRUE, tbl, pdtbl);
-      }
-    } else {
-      tbl = compptr->ac_tbl_no;
-      pdtbl = (d_derived_tbl **)(entropy->derived_tbls) + tbl;
-      jpeg_make_d_derived_tbl(cinfo, FALSE, tbl, pdtbl);
-      /* remember the single active table */
-      entropy->ac_derived_tbl = entropy->derived_tbls[tbl];
-    }
-    /* Initialize DC predictions to 0 */
-    entropy->saved.last_dc_val[ci] = 0;
-  }
-
-  /* Initialize bitread state variables */
-  entropy->bitstate.bits_left = 0;
-  entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */
-  entropy->pub.insufficient_data = FALSE;
-
-  /* Initialize private state variables */
-  entropy->saved.EOBRUN = 0;
-
-  /* Initialize restart counter */
-  entropy->restarts_to_go = cinfo->restart_interval;
-}
-
-
-/*
- * Figure F.12: extend sign bit.
- * On some machines, a shift and add will be faster than a table lookup.
- */
-
-#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))
-
-#else
-
-#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_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 */
-
-
-/*
- * Check for a restart marker & resynchronize decoder.
- * Returns FALSE if must suspend.
- */
-
-LOCAL(boolean)
-process_restart(j_decompress_ptr cinfo)
-{
-  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
-  int ci;
-
-  /* Throw away any unused bits remaining in bit buffer; */
-  /* include any full bytes in next_marker's count of discarded bytes */
-  cinfo->marker->discarded_bytes += entropy->bitstate.bits_left / 8;
-  entropy->bitstate.bits_left = 0;
-
-  /* Advance past the RSTn marker */
-  if (!(*cinfo->marker->read_restart_marker) (cinfo))
-    return FALSE;
-
-  /* Re-initialize DC predictions to 0 */
-  for (ci = 0; ci < cinfo->comps_in_scan; ci++)
-    entropy->saved.last_dc_val[ci] = 0;
-  /* Re-init EOB run count, too */
-  entropy->saved.EOBRUN = 0;
-
-  /* Reset restart counter */
-  entropy->restarts_to_go = cinfo->restart_interval;
-
-  /* Reset out-of-data flag, unless read_restart_marker left us smack up
-   * against a marker.  In that case we will end up treating the next data
-   * segment as empty, and we can avoid producing bogus output pixels by
-   * leaving the flag set.
-   */
-  if (cinfo->unread_marker == 0)
-    entropy->pub.insufficient_data = FALSE;
-
-  return TRUE;
-}
-
-
-/*
- * Huffman MCU decoding.
- * Each of these routines decodes and returns one MCU's worth of
- * Huffman-compressed coefficients.
- * The coefficients are reordered from zigzag order into natural array order,
- * but are not dequantized.
- *
- * The i'th block of the MCU is stored into the block pointed to by
- * MCU_data[i].  WE ASSUME THIS AREA IS INITIALLY ZEROED BY THE CALLER.
- *
- * We return FALSE if data source requested suspension.  In that case no
- * changes have been made to permanent state.  (Exception: some output
- * coefficients may already have been assigned.  This is harmless for
- * spectral selection, since we'll just re-assign them on the next call.
- * Successive approximation AC refinement has to be more careful, however.)
- */
-
-/*
- * MCU decoding for DC initial scan (either spectral selection,
- * or first pass of successive approximation).
- */
-
-METHODDEF(boolean)
-decode_mcu_DC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
-{
-  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
-  int Al = cinfo->Al;
-  register int s, r;
-  int blkn, ci;
-  JBLOCKROW block;
-  BITREAD_STATE_VARS;
-  savable_state state;
-  d_derived_tbl *tbl;
-  jpeg_component_info *compptr;
-
-  /* Process restart marker if needed; may have to suspend */
-  if (cinfo->restart_interval) {
-    if (entropy->restarts_to_go == 0)
-      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) {
-
-    /* Load up working state */
-    BITREAD_LOAD_STATE(cinfo, entropy->bitstate);
-    state = entropy->saved;
-
-    /* Outer loop handles each block in the MCU */
-
-    for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
-      block = MCU_data[blkn];
-      ci = cinfo->MCU_membership[blkn];
-      compptr = cinfo->cur_comp_info[ci];
-      tbl = entropy->derived_tbls[compptr->dc_tbl_no];
-
-      /* Decode a single block's worth of coefficients */
-
-      /* Section F.2.2.1: decode the DC coefficient difference */
-      HUFF_DECODE(s, br_state, tbl, return FALSE, label1);
-      if (s) {
-        CHECK_BIT_BUFFER(br_state, s, return FALSE);
-        r = GET_BITS(s);
-        s = HUFF_EXTEND(r, s);
-      }
-
-      /* 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);
-    }
-
-    /* Completed MCU, so update state */
-    BITREAD_SAVE_STATE(cinfo, entropy->bitstate);
-    entropy->saved = state;
-  }
-
-  /* Account for restart interval (no-op if not using restarts) */
-  if (cinfo->restart_interval)
-    entropy->restarts_to_go--;
-
-  return TRUE;
-}
-
-
-/*
- * MCU decoding for AC initial scan (either spectral selection,
- * or first pass of successive approximation).
- */
-
-METHODDEF(boolean)
-decode_mcu_AC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
-{
-  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
-  int Se = cinfo->Se;
-  int Al = cinfo->Al;
-  register int s, k, r;
-  unsigned int EOBRUN;
-  JBLOCKROW block;
-  BITREAD_STATE_VARS;
-  d_derived_tbl *tbl;
-
-  /* Process restart marker if needed; may have to suspend */
-  if (cinfo->restart_interval) {
-    if (entropy->restarts_to_go == 0)
-      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) {
-
-    /* Load up working state.
-     * We can avoid loading/saving bitread state if in an EOB run.
-     */
-    EOBRUN = entropy->saved.EOBRUN;     /* only part of saved state we need */
-
-    /* There is always only one block per MCU */
-
-    if (EOBRUN > 0)             /* if it's a band of zeroes... */
-      EOBRUN--;                 /* ...process it now (we do nothing) */
-    else {
-      BITREAD_LOAD_STATE(cinfo, entropy->bitstate);
-      block = MCU_data[0];
-      tbl = entropy->ac_derived_tbl;
-
-      for (k = cinfo->Ss; k <= Se; k++) {
-        HUFF_DECODE(s, br_state, tbl, return FALSE, label2);
-        r = s >> 4;
-        s &= 15;
-        if (s) {
-          k += r;
-          CHECK_BIT_BUFFER(br_state, s, return FALSE);
-          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);
-        } else {
-          if (r == 15) {        /* ZRL */
-            k += 15;            /* skip 15 zeroes in band */
-          } else {              /* EOBr, run length is 2^r + appended bits */
-            EOBRUN = 1 << r;
-            if (r) {            /* EOBr, r > 0 */
-              CHECK_BIT_BUFFER(br_state, r, return FALSE);
-              r = GET_BITS(r);
-              EOBRUN += r;
-            }
-            EOBRUN--;           /* this band is processed at this moment */
-            break;              /* force end-of-band */
-          }
-        }
-      }
-
-      BITREAD_SAVE_STATE(cinfo, entropy->bitstate);
-    }
-
-    /* Completed MCU, so update state */
-    entropy->saved.EOBRUN = EOBRUN;     /* only part of saved state we need */
-  }
-
-  /* Account for restart interval (no-op if not using restarts) */
-  if (cinfo->restart_interval)
-    entropy->restarts_to_go--;
-
-  return TRUE;
-}
-
-
-/*
- * MCU decoding for DC successive approximation refinement scan.
- * Note: we assume such scans can be multi-component, although the spec
- * is not very clear on the point.
- */
-
-METHODDEF(boolean)
-decode_mcu_DC_refine(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
-{
-  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;
-  BITREAD_STATE_VARS;
-
-  /* Process restart marker if needed; may have to suspend */
-  if (cinfo->restart_interval) {
-    if (entropy->restarts_to_go == 0)
-      if (!process_restart(cinfo))
-        return FALSE;
-  }
-
-  /* Not worth the cycles to check insufficient_data here,
-   * since we will not change the data anyway if we read zeroes.
-   */
-
-  /* Load up working state */
-  BITREAD_LOAD_STATE(cinfo, entropy->bitstate);
-
-  /* Outer loop handles each block in the MCU */
-
-  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
-    block = MCU_data[blkn];
-
-    /* Encoded data is simply the next bit of the two's-complement DC value */
-    CHECK_BIT_BUFFER(br_state, 1, return FALSE);
-    if (GET_BITS(1))
-      (*block)[0] |= p1;
-    /* Note: since we use |=, repeating the assignment later is safe */
-  }
-
-  /* Completed MCU, so update state */
-  BITREAD_SAVE_STATE(cinfo, entropy->bitstate);
-
-  /* Account for restart interval (no-op if not using restarts) */
-  if (cinfo->restart_interval)
-    entropy->restarts_to_go--;
-
-  return TRUE;
-}
-
-
-/*
- * MCU decoding for AC successive approximation refinement scan.
- */
-
-METHODDEF(boolean)
-decode_mcu_AC_refine(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
-{
-  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 */
-  register int s, k, r;
-  unsigned int EOBRUN;
-  JBLOCKROW block;
-  JCOEFPTR thiscoef;
-  BITREAD_STATE_VARS;
-  d_derived_tbl *tbl;
-  int num_newnz;
-  int newnz_pos[DCTSIZE2];
-
-  /* Process restart marker if needed; may have to suspend */
-  if (cinfo->restart_interval) {
-    if (entropy->restarts_to_go == 0)
-      if (!process_restart(cinfo))
-        return FALSE;
-  }
-
-  /* If we've run out of data, don't modify the MCU.
-   */
-  if (!entropy->pub.insufficient_data) {
-
-    /* Load up working state */
-    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 */
-    block = MCU_data[0];
-    tbl = entropy->ac_derived_tbl;
-
-    /* If we are forced to suspend, we must undo the assignments to any newly
-     * nonzero coefficients in the block, because otherwise we'd get confused
-     * next time about which coefficients were already nonzero.
-     * But we need not undo addition of bits to already-nonzero coefficients;
-     * instead, we can test the current bit to see if we already did it.
-     */
-    num_newnz = 0;
-
-    /* initialize coefficient loop counter to start of band */
-    k = cinfo->Ss;
-
-    if (EOBRUN == 0) {
-      for (; k <= Se; k++) {
-        HUFF_DECODE(s, br_state, tbl, goto undoit, label3);
-        r = s >> 4;
-        s &= 15;
-        if (s) {
-          if (s != 1)           /* size of new coef should always be 1 */
-            WARNMS(cinfo, JWRN_HUFF_BAD_CODE);
-          CHECK_BIT_BUFFER(br_state, 1, goto undoit);
-          if (GET_BITS(1))
-            s = p1;             /* newly nonzero coef is positive */
-          else
-            s = m1;             /* newly nonzero coef is negative */
-        } else {
-          if (r != 15) {
-            EOBRUN = 1 << r;    /* EOBr, run length is 2^r + appended bits */
-            if (r) {
-              CHECK_BIT_BUFFER(br_state, r, goto undoit);
-              r = GET_BITS(r);
-              EOBRUN += r;
-            }
-            break;              /* rest of block is handled by EOB logic */
-          }
-          /* note s = 0 for processing ZRL */
-        }
-        /* Advance over already-nonzero coefs and r still-zero coefs,
-         * appending correction bits to the nonzeroes.  A correction bit is 1
-         * if the absolute value of the coefficient must be increased.
-         */
-        do {
-          thiscoef = *block + jpeg_natural_order[k];
-          if (*thiscoef != 0) {
-            CHECK_BIT_BUFFER(br_state, 1, goto undoit);
-            if (GET_BITS(1)) {
-              if ((*thiscoef & p1) == 0) { /* do nothing if already set it */
-                if (*thiscoef >= 0)
-                  *thiscoef += (JCOEF)p1;
-                else
-                  *thiscoef += (JCOEF)m1;
-              }
-            }
-          } else {
-            if (--r < 0)
-              break;            /* reached target zero coefficient */
-          }
-          k++;
-        } while (k <= Se);
-        if (s) {
-          int pos = jpeg_natural_order[k];
-          /* Output newly nonzero coefficient */
-          (*block)[pos] = (JCOEF)s;
-          /* Remember its position in case we have to suspend */
-          newnz_pos[num_newnz++] = pos;
-        }
-      }
-    }
-
-    if (EOBRUN > 0) {
-      /* Scan any remaining coefficient positions after the end-of-band
-       * (the last newly nonzero coefficient, if any).  Append a correction
-       * bit to each already-nonzero coefficient.  A correction bit is 1
-       * if the absolute value of the coefficient must be increased.
-       */
-      for (; k <= Se; k++) {
-        thiscoef = *block + jpeg_natural_order[k];
-        if (*thiscoef != 0) {
-          CHECK_BIT_BUFFER(br_state, 1, goto undoit);
-          if (GET_BITS(1)) {
-            if ((*thiscoef & p1) == 0) { /* do nothing if already changed it */
-              if (*thiscoef >= 0)
-                *thiscoef += (JCOEF)p1;
-              else
-                *thiscoef += (JCOEF)m1;
-            }
-          }
-        }
-      }
-      /* Count one block completed in EOB run */
-      EOBRUN--;
-    }
-
-    /* Completed MCU, so update state */
-    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--;
-
-  return TRUE;
-
-undoit:
-  /* Re-zero any output coefficients that we made newly nonzero */
-  while (num_newnz > 0)
-    (*block)[newnz_pos[--num_newnz]] = 0;
-
-  return FALSE;
-}
-
-
-/*
- * Module initialization routine for progressive Huffman entropy decoding.
- */
-
-GLOBAL(void)
-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,
-                                sizeof(phuff_entropy_decoder));
-  cinfo->entropy = (struct jpeg_entropy_decoder *)entropy;
-  entropy->pub.start_pass = start_pass_phuff_decoder;
-
-  /* Mark derived tables unallocated */
-  for (i = 0; i < NUM_HUFF_TBLS; i++) {
-    entropy->derived_tbls[i] = NULL;
-  }
-
-  /* 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];
-  for (ci = 0; ci < cinfo->num_components; ci++)
-    for (i = 0; i < DCTSIZE2; i++)
-      *coef_bit_ptr++ = -1;
-}
-
-#endif /* D_PROGRESSIVE_SUPPORTED */
@@ -1,315 +0,0 @@
-/*
- * jdpostct.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1994-1996, Thomas G. Lane.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2022-2023, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains the decompression postprocessing controller.
- * This controller manages the upsampling, color conversion, and color
- * quantization/reduction steps; specifically, it controls the buffering
- * between upsample/color conversion and color quantization/reduction.
- *
- * If no color quantization/reduction is required, then this module has no
- * work to do, and it just hands off to the upsample/color conversion code.
- * An integrated upsample/convert/quantize process would replace this module
- * entirely.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jsamplecomp.h"
-
-
-#if BITS_IN_JSAMPLE != 16 || defined(D_LOSSLESS_SUPPORTED)
-
-/* Private buffer controller object */
-
-typedef struct {
-  struct jpeg_d_post_controller pub; /* public fields */
-
-  /* Color quantization source buffer: this holds output data from
-   * the upsample/color conversion step to be passed to the quantizer.
-   * For two-pass color quantization, we need a full-image buffer;
-   * for one-pass operation, a strip buffer is sufficient.
-   */
-  jvirt_sarray_ptr whole_image; /* virtual array, or NULL if one-pass */
-  _JSAMPARRAY buffer;           /* strip buffer, or current strip of virtual */
-  JDIMENSION strip_height;      /* buffer size in rows */
-  /* for two-pass mode only: */
-  JDIMENSION starting_row;      /* row # of first row in current strip */
-  JDIMENSION next_row;          /* index of next row to fill/empty in strip */
-} my_post_controller;
-
-typedef my_post_controller *my_post_ptr;
-
-
-/* Forward declarations */
-#if BITS_IN_JSAMPLE != 16
-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);
-#endif
-#if defined(QUANT_2PASS_SUPPORTED) && BITS_IN_JSAMPLE != 16
-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
-
-
-/*
- * Initialize for a processing pass.
- */
-
-METHODDEF(void)
-start_pass_dpost(j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
-{
-  my_post_ptr post = (my_post_ptr)cinfo->post;
-
-  switch (pass_mode) {
-  case JBUF_PASS_THRU:
-#if BITS_IN_JSAMPLE != 16
-    if (cinfo->quantize_colors) {
-      /* Single-pass processing with color quantization. */
-      post->pub._post_process_data = post_process_1pass;
-      /* We could be doing buffered-image output before starting a 2-pass
-       * color quantization; in that case, jinit_d_post_controller did not
-       * allocate a strip buffer.  Use the virtual-array buffer as workspace.
-       */
-      if (post->buffer == NULL) {
-        post->buffer = (_JSAMPARRAY)(*cinfo->mem->access_virt_sarray)
-          ((j_common_ptr)cinfo, post->whole_image,
-           (JDIMENSION)0, post->strip_height, TRUE);
-      }
-    } else
-#endif
-    {
-      /* For single-pass processing without color quantization,
-       * I have no work to do; just call the upsampler directly.
-       */
-      post->pub._post_process_data = cinfo->upsample->_upsample;
-    }
-    break;
-#if defined(QUANT_2PASS_SUPPORTED) && BITS_IN_JSAMPLE != 16
-  case JBUF_SAVE_AND_PASS:
-    /* First pass of 2-pass quantization */
-    if (post->whole_image == NULL)
-      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
-    post->pub._post_process_data = post_process_prepass;
-    break;
-  case JBUF_CRANK_DEST:
-    /* Second pass of 2-pass quantization */
-    if (post->whole_image == NULL)
-      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
-    post->pub._post_process_data = post_process_2pass;
-    break;
-#endif /* defined(QUANT_2PASS_SUPPORTED) && BITS_IN_JSAMPLE != 16 */
-  default:
-    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
-    break;
-  }
-  post->starting_row = post->next_row = 0;
-}
-
-
-/*
- * Process some data in the one-pass (strip buffer) case.
- * This is used for color precision reduction as well as one-pass quantization.
- */
-
-#if BITS_IN_JSAMPLE != 16
-
-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)
-{
-  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. */
-  /* Note we rely on the upsampler to detect bottom of image. */
-  max_rows = out_rows_avail - *out_row_ctr;
-  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);
-  /* Quantize and emit data. */
-  (*cinfo->cquantize->_color_quantize) (cinfo, post->buffer,
-                                        output_buf + *out_row_ctr,
-                                        (int)num_rows);
-  *out_row_ctr += num_rows;
-}
-
-#endif
-
-
-#if defined(QUANT_2PASS_SUPPORTED) && BITS_IN_JSAMPLE != 16
-
-/*
- * Process some data in the first pass of 2-pass quantization.
- */
-
-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)
-{
-  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 = (_JSAMPARRAY)(*cinfo->mem->access_virt_sarray)
-        ((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);
-
-  /* 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);
-    *out_row_ctr += num_rows;
-  }
-
-  /* Advance if we filled the strip. */
-  if (post->next_row >= post->strip_height) {
-    post->starting_row += post->strip_height;
-    post->next_row = 0;
-  }
-}
-
-
-/*
- * Process some data in the second pass of 2-pass quantization.
- */
-
-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)
-{
-  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 = (_JSAMPARRAY)(*cinfo->mem->access_virt_sarray)
-        ((j_common_ptr)cinfo, post->whole_image,
-         post->starting_row, post->strip_height, FALSE);
-  }
-
-  /* Determine number of rows to emit. */
-  num_rows = post->strip_height - post->next_row; /* available in strip */
-  max_rows = out_rows_avail - *out_row_ctr; /* available in output area */
-  if (num_rows > max_rows)
-    num_rows = max_rows;
-  /* We have to check bottom of image here, can't depend on upsampler. */
-  max_rows = cinfo->output_height - post->starting_row;
-  if (num_rows > max_rows)
-    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);
-  *out_row_ctr += num_rows;
-
-  /* Advance if we filled the strip. */
-  post->next_row += num_rows;
-  if (post->next_row >= post->strip_height) {
-    post->starting_row += post->strip_height;
-    post->next_row = 0;
-  }
-}
-
-#endif /* defined(QUANT_2PASS_SUPPORTED) && BITS_IN_JSAMPLE != 16 */
-
-
-/*
- * Initialize postprocessing controller.
- */
-
-GLOBAL(void)
-_jinit_d_post_controller(j_decompress_ptr cinfo, boolean need_full_buffer)
-{
-  my_post_ptr post;
-
-  if (cinfo->data_precision != BITS_IN_JSAMPLE)
-    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-
-  post = (my_post_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
-                                sizeof(my_post_controller));
-  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 */
-
-  /* Create the quantization buffer, if needed */
-  if (cinfo->quantize_colors) {
-#if BITS_IN_JSAMPLE != 16
-    /* The buffer strip height is max_v_samp_factor, which is typically
-     * 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;
-    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,
-         cinfo->output_width * cinfo->out_color_components,
-         (JDIMENSION)jround_up((long)cinfo->output_height,
-                               (long)post->strip_height),
-         post->strip_height);
-#else
-      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
-#endif /* QUANT_2PASS_SUPPORTED */
-    } else {
-      /* One-pass color quantization: just make a strip buffer. */
-      post->buffer = (_JSAMPARRAY)(*cinfo->mem->alloc_sarray)
-        ((j_common_ptr)cinfo, JPOOL_IMAGE,
-         cinfo->output_width * cinfo->out_color_components,
-         post->strip_height);
-    }
-#else
-    ERREXIT(cinfo, JERR_NOTIMPL);
-#endif
-  }
-}
-
-#endif /* BITS_IN_JSAMPLE != 16 || defined(D_LOSSLESS_SUPPORTED) */
@@ -1,540 +0,0 @@
-/*
- * jdsample.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1991-1996, Thomas G. Lane.
- * libjpeg-turbo Modifications:
- * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
- * Copyright (C) 2010, 2015-2016, 2022, 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.
- *
- * This file contains upsampling routines.
- *
- * Upsampling input data is counted in "row groups".  A row group
- * is defined to be (v_samp_factor * DCT_scaled_size / min_DCT_scaled_size)
- * sample rows of each component.  Upsampling will normally produce
- * max_v_samp_factor pixel rows from each row group (but this could vary
- * if the upsampler is applying a scale factor of its own).
- *
- * An excellent reference for image resampling is
- *   Digital Image Warping, George Wolberg, 1990.
- *   Pub. by IEEE Computer Society Press, Los Alamitos, CA. ISBN 0-8186-8944-7.
- */
-
-#include "jinclude.h"
-#include "jdsample.h"
-#include "jsimd.h"
-#include "jpegapicomp.h"
-
-
-
-#if BITS_IN_JSAMPLE != 16 || defined(D_LOSSLESS_SUPPORTED)
-
-/*
- * Initialize for an upsampling pass.
- */
-
-METHODDEF(void)
-start_pass_upsample(j_decompress_ptr cinfo)
-{
-  my_upsample_ptr upsample = (my_upsample_ptr)cinfo->upsample;
-
-  /* Mark the conversion buffer empty */
-  upsample->next_row_out = cinfo->max_v_samp_factor;
-  /* Initialize total-height counter for detecting bottom of image */
-  upsample->rows_to_go = cinfo->output_height;
-}
-
-
-/*
- * Control routine to do upsampling (and color conversion).
- *
- * In this version we upsample each component independently.
- * We upsample one row group into the conversion buffer, then apply
- * color conversion a row at a time.
- */
-
-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)
-{
-  my_upsample_ptr upsample = (my_upsample_ptr)cinfo->upsample;
-  int ci;
-  jpeg_component_info *compptr;
-  JDIMENSION num_rows;
-
-  /* Fill the conversion buffer, if it's empty */
-  if (upsample->next_row_out >= cinfo->max_v_samp_factor) {
-    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-         ci++, compptr++) {
-      /* Invoke per-component upsample method.  Notice we pass a POINTER
-       * to color_buf[ci], so that fullsize_upsample can change it.
-       */
-      (*upsample->methods[ci]) (cinfo, compptr,
-        input_buf[ci] + (*in_row_group_ctr * upsample->rowgroup_height[ci]),
-        upsample->color_buf + ci);
-    }
-    upsample->next_row_out = 0;
-  }
-
-  /* Color-convert and emit rows */
-
-  /* How many we have in the buffer: */
-  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:
-   */
-  if (num_rows > upsample->rows_to_go)
-    num_rows = upsample->rows_to_go;
-  /* And not more than what the client can accept: */
-  out_rows_avail -= *out_row_ctr;
-  if (num_rows > out_rows_avail)
-    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);
-
-  /* Adjust counts */
-  *out_row_ctr += num_rows;
-  upsample->rows_to_go -= num_rows;
-  upsample->next_row_out += num_rows;
-  /* When the buffer is emptied, declare this input row group consumed */
-  if (upsample->next_row_out >= cinfo->max_v_samp_factor)
-    (*in_row_group_ctr)++;
-}
-
-
-/*
- * These are the routines invoked by sep_upsample to upsample pixel values
- * of a single component.  One row group is processed per call.
- */
-
-
-/*
- * For full-size components, we just make color_buf[ci] point at the
- * input buffer, and thus avoid copying any data.  Note that this is
- * safe only because sep_upsample doesn't declare the input row group
- * "consumed" until we are done color converting and emitting it.
- */
-
-METHODDEF(void)
-fullsize_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
-                  _JSAMPARRAY input_data, _JSAMPARRAY *output_data_ptr)
-{
-  *output_data_ptr = input_data;
-}
-
-
-/*
- * This is a no-op version used for "uninteresting" components.
- * These components will not be referenced by color conversion.
- */
-
-METHODDEF(void)
-noop_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
-              _JSAMPARRAY input_data, _JSAMPARRAY *output_data_ptr)
-{
-  *output_data_ptr = NULL;      /* safety check */
-}
-
-
-/*
- * This version handles any integral sampling ratios.
- * This is not used for typical JPEG files, so it need not be fast.
- * Nor, for that matter, is it particularly accurate: the algorithm is
- * simple replication of the input pixel onto the corresponding output
- * pixels.  The hi-falutin sampling literature refers to this as a
- * "box filter".  A box filter tends to introduce visible artifacts,
- * so if you are actually going to use 3:1 or 4:1 sampling ratios
- * you would be well advised to improve this code.
- */
-
-METHODDEF(void)
-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;
-  _JSAMPARRAY output_data = *output_data_ptr;
-  register _JSAMPROW inptr, outptr;
-  register _JSAMPLE invalue;
-  register int h;
-  _JSAMPROW outend;
-  int h_expand, v_expand;
-  int inrow, outrow;
-
-  h_expand = upsample->h_expand[compptr->component_index];
-  v_expand = upsample->v_expand[compptr->component_index];
-
-  inrow = outrow = 0;
-  while (outrow < cinfo->max_v_samp_factor) {
-    /* Generate one output row with proper horizontal expansion */
-    inptr = input_data[inrow];
-    outptr = output_data[outrow];
-    outend = outptr + cinfo->output_width;
-    while (outptr < outend) {
-      invalue = *inptr++;
-      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);
-    }
-    inrow++;
-    outrow += v_expand;
-  }
-}
-
-
-/*
- * Fast processing for the common case of 2:1 horizontal and 1:1 vertical.
- * It's still a box filter.
- */
-
-METHODDEF(void)
-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;
-  register _JSAMPLE invalue;
-  _JSAMPROW outend;
-  int inrow;
-
-  for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) {
-    inptr = input_data[inrow];
-    outptr = output_data[inrow];
-    outend = outptr + cinfo->output_width;
-    while (outptr < outend) {
-      invalue = *inptr++;
-      *outptr++ = invalue;
-      *outptr++ = invalue;
-    }
-  }
-}
-
-
-/*
- * Fast processing for the common case of 2:1 horizontal and 2:1 vertical.
- * It's still a box filter.
- */
-
-METHODDEF(void)
-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;
-  register _JSAMPLE invalue;
-  _JSAMPROW outend;
-  int inrow, outrow;
-
-  inrow = outrow = 0;
-  while (outrow < cinfo->max_v_samp_factor) {
-    inptr = input_data[inrow];
-    outptr = output_data[outrow];
-    outend = outptr + cinfo->output_width;
-    while (outptr < outend) {
-      invalue = *inptr++;
-      *outptr++ = invalue;
-      *outptr++ = invalue;
-    }
-    _jcopy_sample_rows(output_data, outrow, output_data, outrow + 1, 1,
-                       cinfo->output_width);
-    inrow++;
-    outrow += 2;
-  }
-}
-
-
-/*
- * Fancy processing for the common case of 2:1 horizontal and 1:1 vertical.
- *
- * The upsampling algorithm is linear interpolation between pixel centers,
- * also known as a "triangle filter".  This is a good compromise between
- * speed and visual quality.  The centers of the output pixels are 1/4 and 3/4
- * of the way between input pixel centers.
- *
- * A note about the "bias" calculations: when rounding fractional values to
- * integer, we do not want to always round 0.5 up to the next integer.
- * If we did that, we'd introduce a noticeable bias towards larger values.
- * Instead, this code is arranged so that 0.5 will be rounded up or down at
- * alternate pixel locations (a simple ordered dither pattern).
- */
-
-METHODDEF(void)
-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;
-  register int invalue;
-  register JDIMENSION colctr;
-  int inrow;
-
-  for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) {
-    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);
-
-    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);
-    }
-
-    /* Special case for last column */
-    invalue = *inptr;
-    *outptr++ = (_JSAMPLE)((invalue * 3 + inptr[-1] + 1) >> 2);
-    *outptr++ = (_JSAMPLE)invalue;
-  }
-}
-
-
-/*
- * Fancy processing for 1:1 horizontal and 2:1 vertical (4:4:0 subsampling).
- *
- * This is a less common case, but it can be encountered when losslessly
- * rotating/transposing a JPEG file that uses 4:2:2 chroma subsampling.
- */
-
-METHODDEF(void)
-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;
-#else
-  JLONG thiscolsum, bias;
-#endif
-  JDIMENSION colctr;
-  int inrow, outrow, v;
-
-  inrow = outrow = 0;
-  while (outrow < cinfo->max_v_samp_factor) {
-    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;
-      }
-      outptr = output_data[outrow++];
-
-      for (colctr = 0; colctr < compptr->downsampled_width; colctr++) {
-        thiscolsum = (*inptr0++) * 3 + (*inptr1++);
-        *outptr++ = (_JSAMPLE)((thiscolsum + bias) >> 2);
-      }
-    }
-    inrow++;
-  }
-}
-
-
-/*
- * Fancy processing for the common case of 2:1 horizontal and 2:1 vertical.
- * Again a triangle filter; see comments for h2v1 case, above.
- *
- * It is OK for us to reference the adjacent input rows because we demanded
- * context from the main buffer controller (see initialization code).
- */
-
-METHODDEF(void)
-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;
-#if BITS_IN_JSAMPLE == 8
-  register int thiscolsum, lastcolsum, nextcolsum;
-#else
-  register JLONG thiscolsum, lastcolsum, nextcolsum;
-#endif
-  register JDIMENSION colctr;
-  int inrow, outrow, v;
-
-  inrow = outrow = 0;
-  while (outrow < cinfo->max_v_samp_factor) {
-    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];
-      else                      /* next nearest is row below */
-        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;
-
-      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;
-      }
-
-      /* Special case for last column */
-      *outptr++ = (_JSAMPLE)((thiscolsum * 3 + lastcolsum + 8) >> 4);
-      *outptr++ = (_JSAMPLE)((thiscolsum * 4 + 7) >> 4);
-    }
-    inrow++;
-  }
-}
-
-
-/*
- * Module initialization routine for upsampling.
- */
-
-GLOBAL(void)
-_jinit_upsampler(j_decompress_ptr cinfo)
-{
-  my_upsample_ptr upsample;
-  int ci;
-  jpeg_component_info *compptr;
-  boolean need_buffer, do_fancy;
-  int h_in_group, v_in_group, h_out_group, v_out_group;
-
-  if (cinfo->data_precision != BITS_IN_JSAMPLE)
-    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
-
-  if (!cinfo->master->jinit_upsampler_no_alloc) {
-    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_upsample;
-    upsample->pub._upsample = sep_upsample;
-    upsample->pub.need_context_rows = FALSE; /* until we find out differently */
-  } else
-    upsample = (my_upsample_ptr)cinfo->upsample;
-
-  if (cinfo->CCIR601_sampling)  /* this isn't supported */
-    ERREXIT(cinfo, JERR_CCIR601_NOTIMPL);
-
-  /* jdmainct.c doesn't support context rows when min_DCT_scaled_size = 1,
-   * so don't ask for it.
-   */
-  do_fancy = cinfo->do_fancy_upsampling && cinfo->_min_DCT_scaled_size > 1;
-
-  /* Verify we can handle the sampling factors, select per-component methods,
-   * and create storage as needed.
-   */
-  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-       ci++, compptr++) {
-    /* Compute size of an "input group" after IDCT scaling.  This many samples
-     * are to be converted to max_h_samp_factor * max_v_samp_factor pixels.
-     */
-    h_in_group = (compptr->h_samp_factor * compptr->_DCT_scaled_size) /
-                 cinfo->_min_DCT_scaled_size;
-    v_in_group = (compptr->v_samp_factor * compptr->_DCT_scaled_size) /
-                 cinfo->_min_DCT_scaled_size;
-    h_out_group = cinfo->max_h_samp_factor;
-    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) {
-      /* Don't bother to upsample an uninteresting component. */
-      upsample->methods[ci] = noop_upsample;
-      need_buffer = FALSE;
-    } else if (h_in_group == h_out_group && v_in_group == v_out_group) {
-      /* 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) {
-      /* Special cases for 2h1v upsampling */
-      if (do_fancy && compptr->downsampled_width > 2) {
-#ifdef WITH_SIMD
-        if (jsimd_can_h2v1_fancy_upsample())
-          upsample->methods[ci] = jsimd_h2v1_fancy_upsample;
-        else
-#endif
-          upsample->methods[ci] = h2v1_fancy_upsample;
-      } else {
-#ifdef WITH_SIMD
-        if (jsimd_can_h2v1_upsample())
-          upsample->methods[ci] = jsimd_h2v1_upsample;
-        else
-#endif
-          upsample->methods[ci] = h2v1_upsample;
-      }
-    } 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(WITH_SIMD) && (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->pub.need_context_rows = TRUE;
-    } else if (h_in_group * 2 == h_out_group &&
-               v_in_group * 2 == v_out_group) {
-      /* Special cases for 2h2v upsampling */
-      if (do_fancy && compptr->downsampled_width > 2) {
-#ifdef WITH_SIMD
-        if (jsimd_can_h2v2_fancy_upsample())
-          upsample->methods[ci] = jsimd_h2v2_fancy_upsample;
-        else
-#endif
-          upsample->methods[ci] = h2v2_fancy_upsample;
-        upsample->pub.need_context_rows = TRUE;
-      } else {
-#ifdef WITH_SIMD
-        if (jsimd_can_h2v2_upsample())
-          upsample->methods[ci] = jsimd_h2v2_upsample;
-        else
-#endif
-          upsample->methods[ci] = h2v2_upsample;
-      }
-    } else if ((h_out_group % h_in_group) == 0 &&
-               (v_out_group % v_in_group) == 0) {
-      /* Generic integral-factors upsampling method */
-#if defined(WITH_SIMD) && defined(__mips__)
-      if (jsimd_can_int_upsample())
-        upsample->methods[ci] = jsimd_int_upsample;
-      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);
-    } else
-      ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL);
-    if (need_buffer && !cinfo->master->jinit_upsampler_no_alloc) {
-      upsample->color_buf[ci] = (_JSAMPARRAY)(*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);
-    }
-  }
-}
-
-#endif /* BITS_IN_JSAMPLE != 16 || defined(D_LOSSLESS_SUPPORTED) */
@@ -1,53 +0,0 @@
-/*
- * jdsample.h
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1991-1996, Thomas G. Lane.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- */
-
-#define JPEG_INTERNALS
-#include "jpeglib.h"
-#include "jsamplecomp.h"
-
-
-/* Pointer to routine to upsample a single component */
-typedef void (*upsample1_ptr) (j_decompress_ptr cinfo,
-                               jpeg_component_info *compptr,
-                               _JSAMPARRAY input_data,
-                               _JSAMPARRAY *output_data_ptr);
-
-/* Private subobject */
-
-typedef struct {
-  struct jpeg_upsampler pub;    /* public fields */
-
-  /* Color conversion buffer.  When using separate upsampling and color
-   * conversion steps, this buffer holds one upsampled row group until it
-   * has been color converted and output.
-   * Note: we do not allocate any storage for component(s) which are full-size,
-   * ie do not need rescaling.  The corresponding entry of color_buf[] is
-   * simply set to point to the input data array, thereby avoiding copying.
-   */
-  _JSAMPARRAY color_buf[MAX_COMPONENTS];
-
-  /* Per-component upsampling method pointers */
-  upsample1_ptr methods[MAX_COMPONENTS];
-
-  int next_row_out;             /* counts rows emitted from color_buf */
-  JDIMENSION rows_to_go;        /* counts rows remaining in image */
-
-  /* Height of an input row group for each component. */
-  int rowgroup_height[MAX_COMPONENTS];
-
-  /* These arrays save pixel expansion factors so that int_expand need not
-   * recompute them each time.  They are unused for other upsampling methods.
-   */
-  UINT8 h_expand[MAX_COMPONENTS];
-  UINT8 v_expand[MAX_COMPONENTS];
-} my_upsampler;
-
-typedef my_upsampler *my_upsample_ptr;
@@ -1,162 +0,0 @@
-/*
- * jdtrans.c
- *
- * This file was part of the Independent JPEG Group's software:
- * Copyright (C) 1995-1997, Thomas G. Lane.
- * libjpeg-turbo Modifications:
- * Copyright (C) 2020, 2022, D. R. Commander.
- * For conditions of distribution and use, see the accompanying README.ijg
- * file.
- *
- * This file contains library routines for transcoding decompression,
- * that is, reading raw DCT coefficient arrays from an input JPEG file.
- * The routines in jdapimin.c will also be needed by a transcoder.
- */
-
-#define JPEG_INTERNALS
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jpegapicomp.h"
-
-
-/* Forward declarations */
-LOCAL(void) transdecode_master_selection(j_decompress_ptr cinfo);
-
-
-/*
- * Read the coefficient arrays from a JPEG file.
- * jpeg_read_header must be completed before calling this.
- *
- * The entire image is read into a set of virtual coefficient-block arrays,
- * one per component.  The return value is a pointer to the array of
- * virtual-array descriptors.  These can be manipulated directly via the
- * JPEG memory manager, or handed off to jpeg_write_coefficients().
- * To release the memory occupied by the virtual arrays, call
- * jpeg_finish_decompress() when done with the data.
- *
- * An alternative usage is to simply obtain access to the coefficient arrays
- * during a buffered-image-mode decompression operation.  This is allowed
- * after any jpeg_finish_output() call.  The arrays can be accessed until
- * jpeg_finish_decompress() is called.  (Note that any call to the library
- * may reposition the arrays, so don't rely on access_virt_barray() results
- * to stay valid across library calls.)
- *
- * Returns NULL if suspended.  This case need be checked only if
- * a suspending data source is used.
- */
-
-GLOBAL(jvirt_barray_ptr *)
-jpeg_read_coefficients(j_decompress_ptr cinfo)
-{
-  if (cinfo->master->lossless)
-    ERREXIT(cinfo, JERR_NOTIMPL);
-
-  if (cinfo->global_state == DSTATE_READY) {
-    /* First call: initialize active modules */
-    transdecode_master_selection(cinfo);
-    cinfo->global_state = DSTATE_RDCOEFS;
-  }
-  if (cinfo->global_state == DSTATE_RDCOEFS) {
-    /* Absorb whole file into the coef buffer */
-    for (;;) {
-      int retcode;
-      /* Call progress monitor hook if present */
-      if (cinfo->progress != NULL)
-        (*cinfo->progress->progress_monitor) ((j_common_ptr)cinfo);
-      /* Absorb some more input */
-      retcode = (*cinfo->inputctl->consume_input) (cinfo);
-      if (retcode == JPEG_SUSPENDED)
-        return NULL;
-      if (retcode == JPEG_REACHED_EOI)
-        break;
-      /* Advance progress counter if appropriate */
-      if (cinfo->progress != NULL &&
-          (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;
-        }
-      }
-    }
-    /* Set state so that jpeg_finish_decompress does the right thing */
-    cinfo->global_state = DSTATE_STOPPING;
-  }
-  /* At this point we should be in state DSTATE_STOPPING if being used
-   * standalone, or in state DSTATE_BUFIMAGE if being invoked to get access
-   * to the coefficients during a full buffered-image-mode decompression.
-   */
-  if ((cinfo->global_state == DSTATE_STOPPING ||
-       cinfo->global_state == DSTATE_BUFIMAGE) && cinfo->buffered_image) {
-    return cinfo->coef->coef_arrays;
-  }
-  /* Oops, improper usage */
-  ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
-  return NULL;                  /* keep compiler happy */
-}
-
-
-/*
- * Master selection of decompression modules for transcoding.
- * This substitutes for jdmaster.c's initialization of the full decompressor.
- */
-
-LOCAL(void)
-transdecode_master_selection(j_decompress_ptr cinfo)
-{
-  /* This is effectively a buffered-image operation. */
-  cinfo->buffered_image = TRUE;
-
-#if JPEG_LIB_VERSION >= 80
-  /* Compute output image dimensions and related values. */
-  jpeg_core_output_dimensions(cinfo);
-#endif
-
-  /* Entropy decoding: either Huffman or arithmetic coding. */
-  if (cinfo->arith_code) {
-#ifdef D_ARITH_CODING_SUPPORTED
-    jinit_arith_decoder(cinfo);
-#else
-    ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
-#endif
-  } else {
-    if (cinfo->progressive_mode) {
-#ifdef D_PROGRESSIVE_SUPPORTED
-      jinit_phuff_decoder(cinfo);
-#else
-      ERREXIT(cinfo, JERR_NOT_COMPILED);
-#endif
-    } else
-      jinit_huff_decoder(cinfo);
-  }
-
-  /* Always get a full-image coefficient buffer. */
-  if (cinfo->data_precision == 12)
-    j12init_d_coef_controller(cinfo, TRUE);
-  else
-    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);
-
-  /* Initialize input side of decompressor to consume first scan. */
-  (*cinfo->inputctl->start_input_pass) (cinfo);
-
-  /* Initialize progress monitoring. */
-  if (cinfo->progress != NULL) {
-    int nscans;
-    /* Estimate number of scans to set pass_limit. */
-    if (cinfo->progressive_mode) {
-      /* Arbitrarily estimate 2 interleaved DC scans + 3 AC scans/component. */
-      nscans = 2 + 3 * cinfo->num_components;
-    } else if (cinfo->inputctl->has_multiple_scans) {
-      /* For a nonprogressive multiscan file, estimate 1 scan per component. */
-      nscans = cinfo->num_components;
-    } else {
-      nscans = 1;
-    }
-    cinfo->progress->pass_counter = 0L;
-    cinfo->progress->pass_limit = (long)cinfo->total_iMCU_rows * nscans;
-    cinfo->progress->completed_passes = 0;
-    cinfo->progress->total_passes = 1;
-  }
-}
--- a/Show More
+++ b/Show More