fast_resize 1.0.2 → 1.0.3

data/src/pipeline.cpp

@@ -1,284 +0,0 @@
-/*
- * FastResize - The Fastest Image Resizing Library On The Planet
- * Copyright (C) 2025 Tran Huu Canh (0xTh3OKrypt) and FastResize Contributors
- *
- * Resize 1,000 images in 2 seconds. Up to 2.9x faster than libvips,
- * 3.1x faster than imageflow. Uses 3-4x less RAM than alternatives.
- *
- * Author: Tran Huu Canh (0xTh3OKrypt)
- * Email: tranhuucanh39@gmail.com
- * Homepage: https://github.com/tranhuucanh/fast_resize
- *
- * BSD 3-Clause License
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * 1. Redistributions of source code must retain the above copyright notice,
- *    this list of conditions and the following disclaimer.
- *
- * 2. 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.
- *
- * 3. Neither the name of the copyright holder 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 HOLDER 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.
- */
-
-#include "pipeline.h"
-#include <thread>
-
-namespace fastresize {
-namespace internal {
-
-PipelineProcessor::PipelineProcessor(
-    size_t decode_threads,
-    size_t resize_threads,
-    size_t encode_threads,
-    size_t queue_capacity
-)
-    : decode_pool_(nullptr)
-    , resize_pool_(nullptr)
-    , encode_pool_(nullptr)
-    , decode_queue_(queue_capacity)
-    , resize_queue_(queue_capacity)
-    , success_count_(0)
-    , failed_count_(0)
-{
-    decode_pool_ = create_thread_pool(decode_threads);
-    resize_pool_ = create_thread_pool(resize_threads);
-    encode_pool_ = create_thread_pool(encode_threads);
-
-    for (size_t i = 0; i < encode_threads; ++i) {
-        encode_buffer_pools_.push_back(create_buffer_pool());
-    }
-}
-
-PipelineProcessor::~PipelineProcessor() {
-    if (decode_pool_) destroy_thread_pool(decode_pool_);
-    if (resize_pool_) destroy_thread_pool(resize_pool_);
-    if (encode_pool_) destroy_thread_pool(encode_pool_);
-
-    for (BufferPool* pool : encode_buffer_pools_) {
-        destroy_buffer_pool(pool);
-    }
-}
-
-void PipelineProcessor::decode_stage(const std::vector<BatchItem>& items) {
-    for (size_t i = 0; i < items.size(); ++i) {
-        thread_pool_enqueue(decode_pool_, [this, &items, i]() {
-            const auto& item = items[i];
-
-            DecodeResult result;
-            result.task_id = i;
-            result.output_path = item.output_path;
-            result.options = item.options;
-            result.success = false;
-
-            ImageFormat fmt = detect_format(item.input_path);
-            if (fmt == FORMAT_UNKNOWN) {
-                result.error_message = "Unknown format: " + item.input_path;
-                decode_queue_.push(std::move(result));
-                return;
-            }
-
-            result.image = decode_image(item.input_path, fmt);
-            if (result.image.pixels == nullptr) {
-                result.error_message = "Decode failed: " + item.input_path;
-                decode_queue_.push(std::move(result));
-                return;
-            }
-
-            result.success = true;
-            decode_queue_.push(std::move(result));
-        });
-    }
-
-    thread_pool_wait(decode_pool_);
-    decode_queue_.set_done();
-}
-
-void PipelineProcessor::resize_stage() {
-    std::vector<std::thread> workers;
-    for (size_t i = 0; i < 8; ++i) {
-        workers.emplace_back([this]() {
-            DecodeResult decode_result;
-
-            while (decode_queue_.pop(decode_result)) {
-                ResizeResult resize_result;
-                resize_result.task_id = decode_result.task_id;
-                resize_result.output_path = decode_result.output_path;
-                resize_result.options = decode_result.options;
-                resize_result.success = false;
-
-                if (!decode_result.success) {
-                    resize_result.error_message = decode_result.error_message;
-                    resize_result.pixels = nullptr;
-                    resize_result.width = 0;
-                    resize_result.height = 0;
-                    resize_result.channels = 0;
-                    resize_queue_.push(std::move(resize_result));
-                    continue;
-                }
-
-                int out_w, out_h;
-                calculate_dimensions(
-                    decode_result.image.width,
-                    decode_result.image.height,
-                    decode_result.options,
-                    out_w, out_h
-                );
-
-                unsigned char* resized_pixels = nullptr;
-                bool resize_ok = resize_image(
-                    decode_result.image.pixels,
-                    decode_result.image.width,
-                    decode_result.image.height,
-                    decode_result.image.channels,
-                    &resized_pixels,
-                    out_w, out_h,
-                    decode_result.options
-                );
-
-                free_image_data(decode_result.image);
-
-                if (!resize_ok || resized_pixels == nullptr) {
-                    resize_result.error_message = "Resize failed";
-                    resize_result.pixels = nullptr;
-                    resize_result.width = 0;
-                    resize_result.height = 0;
-                    resize_result.channels = 0;
-                    resize_queue_.push(std::move(resize_result));
-                    continue;
-                }
-
-                resize_result.pixels = resized_pixels;
-                resize_result.width = out_w;
-                resize_result.height = out_h;
-                resize_result.channels = decode_result.image.channels;
-                resize_result.success = true;
-                resize_queue_.push(std::move(resize_result));
-            }
-        });
-    }
-
-    for (auto& worker : workers) {
-        worker.join();
-    }
-
-    resize_queue_.set_done();
-}
-
-void PipelineProcessor::encode_stage() {
-    std::vector<std::thread> workers;
-    for (size_t i = 0; i < encode_buffer_pools_.size(); ++i) {
-        workers.emplace_back([this, i]() {
-            BufferPool* buffer_pool = encode_buffer_pools_[i];
-            ResizeResult resize_result;
-
-            while (resize_queue_.pop(resize_result)) {
-                if (!resize_result.success) {
-                    failed_count_.fetch_add(1);
-                    if (!resize_result.error_message.empty()) {
-                        std::lock_guard<std::mutex> lock(errors_mutex_);
-                        errors_.push_back(resize_result.error_message);
-                    }
-                    continue;
-                }
-
-                ImageFormat out_fmt = FORMAT_UNKNOWN;
-                size_t dot_pos = resize_result.output_path.find_last_of('.');
-                if (dot_pos != std::string::npos) {
-                    std::string ext = resize_result.output_path.substr(dot_pos + 1);
-                    for (char& c : ext) {
-                        if (c >= 'A' && c <= 'Z') c = c - 'A' + 'a';
-                    }
-                    out_fmt = string_to_format(ext);
-                }
-
-                if (out_fmt == FORMAT_UNKNOWN) {
-                    out_fmt = FORMAT_JPEG;
-                }
-
-                if (resize_result.pixels == nullptr || resize_result.width <= 0 ||
-                    resize_result.height <= 0 || resize_result.channels <= 0) {
-                    failed_count_.fetch_add(1);
-                    std::lock_guard<std::mutex> lock(errors_mutex_);
-                    errors_.push_back("Invalid resize data for: " + resize_result.output_path);
-                    if (resize_result.pixels) delete[] resize_result.pixels;
-                    continue;
-                }
-
-                ImageData img_data;
-                img_data.pixels = resize_result.pixels;
-                img_data.width = resize_result.width;
-                img_data.height = resize_result.height;
-                img_data.channels = resize_result.channels;
-
-                bool encode_ok = encode_image(
-                    resize_result.output_path,
-                    img_data,
-                    out_fmt,
-                    resize_result.options.quality,
-                    buffer_pool
-                );
-
-                delete[] resize_result.pixels;
-
-                if (encode_ok) {
-                    success_count_.fetch_add(1);
-                } else {
-                    failed_count_.fetch_add(1);
-                    std::lock_guard<std::mutex> lock(errors_mutex_);
-                    char buf[512];
-                    snprintf(buf, sizeof(buf), "Encode failed: %s (fmt=%d, %dx%d, %dch)",
-                             resize_result.output_path.c_str(), (int)out_fmt,
-                             resize_result.width, resize_result.height, resize_result.channels);
-                    errors_.push_back(buf);
-                }
-            }
-        });
-    }
-
-    for (auto& worker : workers) {
-        worker.join();
-    }
-}
-
-BatchResult PipelineProcessor::process_batch(const std::vector<BatchItem>& items) {
-    success_count_ = 0;
-    failed_count_ = 0;
-    errors_.clear();
-
-    std::thread decode_thread([this, &items]() { decode_stage(items); });
-    std::thread resize_thread([this]() { resize_stage(); });
-    std::thread encode_thread([this]() { encode_stage(); });
-
-    decode_thread.join();
-    resize_thread.join();
-    encode_thread.join();
-
-    BatchResult result;
-    result.total = items.size();
-    result.success = success_count_.load();
-    result.failed = failed_count_.load();
-    result.errors = errors_;
-
-    return result;
-}
-
-}
-}

data/src/pipeline.h

@@ -1,175 +0,0 @@
-/*
- * FastResize - The Fastest Image Resizing Library On The Planet
- * Copyright (C) 2025 Tran Huu Canh (0xTh3OKrypt) and FastResize Contributors
- *
- * Resize 1,000 images in 2 seconds. Up to 2.9x faster than libvips,
- * 3.1x faster than imageflow. Uses 3-4x less RAM than alternatives.
- *
- * Author: Tran Huu Canh (0xTh3OKrypt)
- * Email: tranhuucanh39@gmail.com
- * Homepage: https://github.com/tranhuucanh/fast_resize
- *
- * BSD 3-Clause License
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * 1. Redistributions of source code must retain the above copyright notice,
- *    this list of conditions and the following disclaimer.
- *
- * 2. 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.
- *
- * 3. Neither the name of the copyright holder 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 HOLDER 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.
- */
-
-#pragma once
-
-#include "internal.h"
-#include <queue>
-#include <mutex>
-#include <condition_variable>
-#include <thread>
-#include <atomic>
-
-namespace fastresize {
-namespace internal {
-
-template<typename T>
-class BoundedQueue {
-public:
-    BoundedQueue(size_t capacity)
-        : capacity_(capacity)
-        , done_(false)
-    {}
-
-    bool push(T&& item) {
-        std::unique_lock<std::mutex> lock(mutex_);
-
-        cv_not_full_.wait(lock, [this]() {
-            return queue_.size() < capacity_ || done_;
-        });
-
-        if (done_) return false;
-
-        queue_.push(std::move(item));
-        lock.unlock();
-        cv_not_empty_.notify_one();
-        return true;
-    }
-
-    bool pop(T& item) {
-        std::unique_lock<std::mutex> lock(mutex_);
-
-        cv_not_empty_.wait(lock, [this]() {
-            return !queue_.empty() || done_;
-        });
-
-        if (queue_.empty() && done_) return false;
-
-        item = std::move(queue_.front());
-        queue_.pop();
-        lock.unlock();
-        cv_not_full_.notify_one();
-        return true;
-    }
-
-    void set_done() {
-        std::unique_lock<std::mutex> lock(mutex_);
-        done_ = true;
-        lock.unlock();
-        cv_not_empty_.notify_all();
-        cv_not_full_.notify_all();
-    }
-
-    size_t size() const {
-        std::lock_guard<std::mutex> lock(mutex_);
-        return queue_.size();
-    }
-
-private:
-    size_t capacity_;
-    std::queue<T> queue_;
-    mutable std::mutex mutex_;
-    std::condition_variable cv_not_empty_;
-    std::condition_variable cv_not_full_;
-    bool done_;
-};
-
-struct DecodeTask {
-    std::string input_path;
-    std::string output_path;
-    ResizeOptions options;
-    int task_id;
-};
-
-struct DecodeResult {
-    ImageData image;
-    std::string output_path;
-    ResizeOptions options;
-    int task_id;
-    bool success;
-    std::string error_message;
-};
-
-struct ResizeResult {
-    unsigned char* pixels;
-    int width;
-    int height;
-    int channels;
-    std::string output_path;
-    ResizeOptions options;
-    int task_id;
-    bool success;
-    std::string error_message;
-};
-
-class PipelineProcessor {
-public:
-    PipelineProcessor(
-        size_t decode_threads = 4,
-        size_t resize_threads = 8,
-        size_t encode_threads = 4,
-        size_t queue_capacity = 32
-    );
-
-    ~PipelineProcessor();
-    BatchResult process_batch(const std::vector<BatchItem>& items);
-
-private:
-    ThreadPool* decode_pool_;
-    ThreadPool* resize_pool_;
-    ThreadPool* encode_pool_;
-
-    std::vector<BufferPool*> encode_buffer_pools_;
-
-    BoundedQueue<DecodeResult> decode_queue_;
-    BoundedQueue<ResizeResult> resize_queue_;
-
-    std::atomic<int> success_count_;
-    std::atomic<int> failed_count_;
-    std::mutex errors_mutex_;
-    std::vector<std::string> errors_;
-
-    void decode_stage(const std::vector<BatchItem>& items);
-    void resize_stage();
-    void encode_stage();
-};
-
-}
-}

data/src/resizer.cpp

@@ -1,199 +0,0 @@
-/*
- * FastResize - The Fastest Image Resizing Library On The Planet
- * Copyright (C) 2025 Tran Huu Canh (0xTh3OKrypt) and FastResize Contributors
- *
- * Resize 1,000 images in 2 seconds. Up to 2.9x faster than libvips,
- * 3.1x faster than imageflow. Uses 3-4x less RAM than alternatives.
- *
- * Author: Tran Huu Canh (0xTh3OKrypt)
- * Email: tranhuucanh39@gmail.com
- * Homepage: https://github.com/tranhuucanh/fast_resize
- *
- * BSD 3-Clause License
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * 1. Redistributions of source code must retain the above copyright notice,
- *    this list of conditions and the following disclaimer.
- *
- * 2. 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.
- *
- * 3. Neither the name of the copyright holder 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 HOLDER 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.
- */
-
-#include "internal.h"
-#include "simd_resize.h"
-#include <cmath>
-
-#define STB_IMAGE_RESIZE_IMPLEMENTATION
-#include "stb_image_resize2.h"
-
-namespace fastresize {
-namespace internal {
-
-void calculate_dimensions(
-    int in_w, int in_h,
-    const ResizeOptions& opts,
-    int& out_w, int& out_h
-) {
-    switch (opts.mode) {
-        case ResizeOptions::SCALE_PERCENT:
-            out_w = static_cast<int>(std::round(in_w * opts.scale_percent));
-            out_h = static_cast<int>(std::round(in_h * opts.scale_percent));
-            break;
-
-        case ResizeOptions::FIT_WIDTH:
-            out_w = opts.target_width;
-            if (opts.keep_aspect_ratio) {
-                float ratio = static_cast<float>(out_w) / in_w;
-                out_h = static_cast<int>(std::round(in_h * ratio));
-            } else {
-                out_h = in_h;
-            }
-            break;
-
-        case ResizeOptions::FIT_HEIGHT:
-            out_h = opts.target_height;
-            if (opts.keep_aspect_ratio) {
-                float ratio = static_cast<float>(out_h) / in_h;
-                out_w = static_cast<int>(std::round(in_w * ratio));
-            } else {
-                out_w = in_w;
-            }
-            break;
-
-        case ResizeOptions::EXACT_SIZE:
-            out_w = opts.target_width;
-            out_h = opts.target_height;
-            if (opts.keep_aspect_ratio) {
-                float ratio_w = static_cast<float>(out_w) / in_w;
-                float ratio_h = static_cast<float>(out_h) / in_h;
-                float ratio = std::min(ratio_w, ratio_h);
-                out_w = static_cast<int>(std::round(in_w * ratio));
-                out_h = static_cast<int>(std::round(in_h * ratio));
-            }
-            break;
-    }
-
-    if (out_w < 1) out_w = 1;
-    if (out_h < 1) out_h = 1;
-}
-
-bool resize_image(
-    const unsigned char* input_pixels,
-    int input_w, int input_h, int channels,
-    unsigned char** output_pixels,
-    int output_w, int output_h,
-    const ResizeOptions& opts
-) {
-    if (!input_pixels || input_w <= 0 || input_h <= 0 ||
-        output_w <= 0 || output_h <= 0 || channels <= 0) {
-        set_last_error(RESIZE_ERROR, "Invalid input parameters for resize");
-        return false;
-    }
-
-    size_t output_size = static_cast<size_t>(output_w) * output_h * channels;
-    *output_pixels = new unsigned char[output_size];
-
-    float downscale_ratio_w = static_cast<float>(input_w) / output_w;
-    float downscale_ratio_h = static_cast<float>(input_h) / output_h;
-    float max_downscale = (downscale_ratio_w > downscale_ratio_h) ? downscale_ratio_w : downscale_ratio_h;
-
-    stbir_filter stb_filter;
-
-    if (max_downscale >= 3.0f && opts.filter == ResizeOptions::MITCHELL) {
-        stb_filter = STBIR_FILTER_TRIANGLE;
-    } else {
-        switch (opts.filter) {
-            case ResizeOptions::MITCHELL:
-                stb_filter = STBIR_FILTER_MITCHELL;
-                break;
-            case ResizeOptions::CATMULL_ROM:
-                stb_filter = STBIR_FILTER_CATMULLROM;
-                break;
-            case ResizeOptions::BOX:
-                stb_filter = STBIR_FILTER_BOX;
-                break;
-            case ResizeOptions::TRIANGLE:
-                stb_filter = STBIR_FILTER_TRIANGLE;
-                break;
-            default:
-                stb_filter = STBIR_FILTER_MITCHELL;
-        }
-    }
-
-    bool use_simd = (output_w < input_w && output_h < input_h) &&
-                    (stb_filter == STBIR_FILTER_TRIANGLE ||
-                     (stb_filter == STBIR_FILTER_MITCHELL && max_downscale < 3.0f)) &&
-                    (channels == 3 || channels == 4 || channels == 1);
-
-    if (use_simd) {
-        bool simd_ok = simd_resize(
-            input_pixels, input_w, input_h, channels,
-            *output_pixels, output_w, output_h,
-            ResizeQuality::FAST
-        );
-
-        if (simd_ok) {
-            return true;
-        }
-    }
-
-    stbir_pixel_layout pixel_layout;
-    switch (channels) {
-        case 1:
-            pixel_layout = STBIR_1CHANNEL;
-            break;
-        case 2:
-            pixel_layout = STBIR_2CHANNEL;
-            break;
-        case 3:
-            pixel_layout = STBIR_RGB;
-            break;
-        case 4:
-            pixel_layout = STBIR_RGBA;
-            break;
-        default:
-            delete[] *output_pixels;
-            *output_pixels = nullptr;
-            set_last_error(RESIZE_ERROR, "Unsupported number of channels");
-            return false;
-    }
-
-    void* result = stbir_resize(
-        input_pixels, input_w, input_h, 0,
-        *output_pixels, output_w, output_h, 0,
-        pixel_layout, STBIR_TYPE_UINT8,
-        STBIR_EDGE_CLAMP,
-        stb_filter
-    );
-
-    if (!result) {
-        delete[] *output_pixels;
-        *output_pixels = nullptr;
-        set_last_error(RESIZE_ERROR, "stb_image_resize2 failed");
-        return false;
-    }
-
-    return true;
-}
-
-}
-}