fast_resize 1.0.2 → 1.0.3

data/src/simd_resize.cpp

@@ -1,384 +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 "simd_resize.h"
-#include <cstring>
-#include <cmath>
-#include <algorithm>
-
-#if defined(__ARM_NEON) || defined(__aarch64__)
-    #define USE_NEON 1
-    #include <arm_neon.h>
-#elif defined(__AVX2__)
-    #define USE_AVX2 1
-    #include <immintrin.h>
-#elif defined(__SSE2__) || defined(__x86_64__) || defined(_M_X64)
-    #define USE_SSE2 1
-    #include <emmintrin.h>
-#endif
-
-namespace fastresize {
-namespace internal {
-
-static void resize_bilinear_scalar(
-    const uint8_t* src, int src_w, int src_h, int channels,
-    uint8_t* dst, int dst_w, int dst_h
-) {
-    const int FRAC_BITS = 16;
-    const int FRAC_ONE = 1 << FRAC_BITS;
-
-    int x_ratio = ((src_w - 1) << FRAC_BITS) / dst_w;
-    int y_ratio = ((src_h - 1) << FRAC_BITS) / dst_h;
-
-    int src_stride = src_w * channels;
-    int dst_stride = dst_w * channels;
-
-    for (int y = 0; y < dst_h; y++) {
-        int src_y_fp = y * y_ratio;
-        int y1 = src_y_fp >> FRAC_BITS;
-        int y2 = std::min(y1 + 1, src_h - 1);
-        int y_frac = src_y_fp & (FRAC_ONE - 1);
-        int y_frac_inv = FRAC_ONE - y_frac;
-
-        const uint8_t* row1 = src + y1 * src_stride;
-        const uint8_t* row2 = src + y2 * src_stride;
-        uint8_t* out_row = dst + y * dst_stride;
-
-        for (int x = 0; x < dst_w; x++) {
-            int src_x_fp = x * x_ratio;
-            int x1 = src_x_fp >> FRAC_BITS;
-            int x2 = std::min(x1 + 1, src_w - 1);
-            int x_frac = src_x_fp & (FRAC_ONE - 1);
-            int x_frac_inv = FRAC_ONE - x_frac;
-
-            const uint8_t* p1 = row1 + x1 * channels;
-            const uint8_t* p2 = row1 + x2 * channels;
-            const uint8_t* p3 = row2 + x1 * channels;
-            const uint8_t* p4 = row2 + x2 * channels;
-
-            int w1 = (x_frac_inv * y_frac_inv) >> FRAC_BITS;
-            int w2 = (x_frac * y_frac_inv) >> FRAC_BITS;
-            int w3 = (x_frac_inv * y_frac) >> FRAC_BITS;
-            int w4 = (x_frac * y_frac) >> FRAC_BITS;
-
-            uint8_t* out = out_row + x * channels;
-
-            for (int c = 0; c < channels; c++) {
-                int val = (p1[c] * w1 + p2[c] * w2 + p3[c] * w3 + p4[c] * w4) >> FRAC_BITS;
-                out[c] = (uint8_t)std::min(val, 255);
-            }
-        }
-    }
-}
-
-#ifdef USE_NEON
-
-static void resize_bilinear_neon_rgba(
-    const uint8_t* __restrict src, int src_w, int src_h,
-    uint8_t* __restrict dst, int dst_w, int dst_h,
-    int channels
-) {
-    const int FRAC_BITS = 8;
-    const int FRAC_ONE = 1 << FRAC_BITS;
-
-    int x_ratio_fp = ((src_w - 1) << 16) / dst_w;
-    int y_ratio_fp = ((src_h - 1) << 16) / dst_h;
-
-    int src_stride = src_w * channels;
-    int dst_stride = dst_w * channels;
-
-    for (int y = 0; y < dst_h; y++) {
-        int src_y_fp = (y * y_ratio_fp) >> 8;
-        int y1 = src_y_fp >> FRAC_BITS;
-        int y2 = std::min(y1 + 1, src_h - 1);
-        int y_frac = src_y_fp & (FRAC_ONE - 1);
-
-        int16x8_t wy2_vec = vdupq_n_s16(y_frac);
-        int16x8_t wy1_vec = vdupq_n_s16(FRAC_ONE - y_frac);
-
-        const uint8_t* row1 = src + y1 * src_stride;
-        const uint8_t* row2 = src + y2 * src_stride;
-        uint8_t* out_row = dst + y * dst_stride;
-
-        int x = 0;
-
-        for (; x + 4 <= dst_w; x += 4) {
-            int src_x_fp[4];
-            int x1_arr[4], x2_arr[4], x_frac_arr[4];
-
-            for (int i = 0; i < 4; i++) {
-                src_x_fp[i] = ((x + i) * x_ratio_fp) >> 8;
-                x1_arr[i] = src_x_fp[i] >> FRAC_BITS;
-                x2_arr[i] = std::min(x1_arr[i] + 1, src_w - 1);
-                x_frac_arr[i] = src_x_fp[i] & (FRAC_ONE - 1);
-            }
-
-            if (channels == 4) {
-                for (int i = 0; i < 4; i++) {
-                    uint8x8_t tl = vld1_u8(row1 + x1_arr[i] * 4);
-                    uint8x8_t tr = vld1_u8(row1 + x2_arr[i] * 4);
-                    uint8x8_t bl = vld1_u8(row2 + x1_arr[i] * 4);
-                    uint8x8_t br = vld1_u8(row2 + x2_arr[i] * 4);
-
-                    int16x8_t tl16 = vreinterpretq_s16_u16(vmovl_u8(tl));
-                    int16x8_t tr16 = vreinterpretq_s16_u16(vmovl_u8(tr));
-                    int16x8_t bl16 = vreinterpretq_s16_u16(vmovl_u8(bl));
-                    int16x8_t br16 = vreinterpretq_s16_u16(vmovl_u8(br));
-
-                    int16_t wx2 = x_frac_arr[i];
-                    int16_t wx1 = FRAC_ONE - wx2;
-                    int16x8_t wx1_vec = vdupq_n_s16(wx1);
-                    int16x8_t wx2_vec = vdupq_n_s16(wx2);
-
-                    int16x8_t top = vaddq_s16(
-                        vmulq_s16(tl16, wx1_vec),
-                        vmulq_s16(tr16, wx2_vec)
-                    );
-                    int16x8_t bottom = vaddq_s16(
-                        vmulq_s16(bl16, wx1_vec),
-                        vmulq_s16(br16, wx2_vec)
-                    );
-
-                    top = vshrq_n_s16(top, FRAC_BITS);
-                    bottom = vshrq_n_s16(bottom, FRAC_BITS);
-
-                    int16x8_t result = vaddq_s16(
-                        vmulq_s16(top, wy1_vec),
-                        vmulq_s16(bottom, wy2_vec)
-                    );
-                    result = vshrq_n_s16(result, FRAC_BITS);
-
-                    uint8x8_t result8 = vqmovun_s16(result);
-
-                    vst1_lane_u32((uint32_t*)(out_row + (x + i) * 4),
-                                  vreinterpret_u32_u8(result8), 0);
-                }
-            } else if (channels == 3) {
-                for (int i = 0; i < 4; i++) {
-                    const uint8_t* p_tl = row1 + x1_arr[i] * 3;
-                    const uint8_t* p_tr = row1 + x2_arr[i] * 3;
-                    const uint8_t* p_bl = row2 + x1_arr[i] * 3;
-                    const uint8_t* p_br = row2 + x2_arr[i] * 3;
-
-                    int16_t wx2 = x_frac_arr[i];
-                    int16_t wx1 = FRAC_ONE - wx2;
-                    int16_t wy1 = FRAC_ONE - y_frac;
-                    int16_t wy2 = y_frac;
-
-                    uint8_t* out = out_row + (x + i) * 3;
-
-                    for (int c = 0; c < 3; c++) {
-                        int top = (p_tl[c] * wx1 + p_tr[c] * wx2) >> FRAC_BITS;
-                        int bottom = (p_bl[c] * wx1 + p_br[c] * wx2) >> FRAC_BITS;
-                        int val = (top * wy1 + bottom * wy2) >> FRAC_BITS;
-                        out[c] = (uint8_t)std::min(std::max(val, 0), 255);
-                    }
-                }
-            }
-        }
-
-        for (; x < dst_w; x++) {
-            int src_x_fp = (x * x_ratio_fp) >> 8;
-            int x1 = src_x_fp >> FRAC_BITS;
-            int x2 = std::min(x1 + 1, src_w - 1);
-            int x_frac = src_x_fp & (FRAC_ONE - 1);
-            int x_frac_inv = FRAC_ONE - x_frac;
-            int y_frac_inv = FRAC_ONE - y_frac;
-
-            const uint8_t* p1 = row1 + x1 * channels;
-            const uint8_t* p2 = row1 + x2 * channels;
-            const uint8_t* p3 = row2 + x1 * channels;
-            const uint8_t* p4 = row2 + x2 * channels;
-
-            int w1 = (x_frac_inv * y_frac_inv) >> FRAC_BITS;
-            int w2 = (x_frac * y_frac_inv) >> FRAC_BITS;
-            int w3 = (x_frac_inv * y_frac) >> FRAC_BITS;
-            int w4 = (x_frac * y_frac) >> FRAC_BITS;
-
-            uint8_t* out = out_row + x * channels;
-
-            for (int c = 0; c < channels; c++) {
-                int val = (p1[c] * w1 + p2[c] * w2 + p3[c] * w3 + p4[c] * w4) >> FRAC_BITS;
-                out[c] = (uint8_t)std::min(val, 255);
-            }
-        }
-    }
-}
-
-static void resize_area_neon(
-    const uint8_t* __restrict src, int src_w, int src_h,
-    uint8_t* __restrict dst, int dst_w, int dst_h,
-    int channels
-) {
-    float x_scale = (float)src_w / dst_w;
-    float y_scale = (float)src_h / dst_h;
-
-    int src_stride = src_w * channels;
-    int dst_stride = dst_w * channels;
-
-    for (int dy = 0; dy < dst_h; dy++) {
-        int sy_start = (int)(dy * y_scale);
-        int sy_end = std::min((int)((dy + 1) * y_scale), src_h);
-        int y_count = sy_end - sy_start;
-        if (y_count < 1) y_count = 1;
-
-        uint8_t* out_row = dst + dy * dst_stride;
-
-        for (int dx = 0; dx < dst_w; dx++) {
-            int sx_start = (int)(dx * x_scale);
-            int sx_end = std::min((int)((dx + 1) * x_scale), src_w);
-            int x_count = sx_end - sx_start;
-            if (x_count < 1) x_count = 1;
-
-            int pixel_count = x_count * y_count;
-
-            if (channels == 4) {
-                uint32x4_t sum = vdupq_n_u32(0);
-
-                for (int sy = sy_start; sy < sy_end; sy++) {
-                    const uint8_t* src_row = src + sy * src_stride + sx_start * 4;
-
-                    int sx = 0;
-                    for (; sx + 4 <= x_count; sx += 4) {
-                        uint8x16_t pixels = vld1q_u8(src_row + sx * 4);
-
-                        uint16x8_t lo = vmovl_u8(vget_low_u8(pixels));
-                        uint16x8_t hi = vmovl_u8(vget_high_u8(pixels));
-
-                        sum = vaddq_u32(sum, vmovl_u16(vget_low_u16(lo)));
-                        sum = vaddq_u32(sum, vmovl_u16(vget_high_u16(lo)));
-                        sum = vaddq_u32(sum, vmovl_u16(vget_low_u16(hi)));
-                        sum = vaddq_u32(sum, vmovl_u16(vget_high_u16(hi)));
-                    }
-
-                    for (; sx < x_count; sx++) {
-                        const uint8_t* p = src_row + sx * 4;
-                        uint32_t vals[4] = {p[0], p[1], p[2], p[3]};
-                        sum = vaddq_u32(sum, vld1q_u32(vals));
-                    }
-                }
-
-                uint32_t sums[4];
-                vst1q_u32(sums, sum);
-
-                uint8_t* out = out_row + dx * 4;
-                out[0] = sums[0] / pixel_count;
-                out[1] = sums[1] / pixel_count;
-                out[2] = sums[2] / pixel_count;
-                out[3] = sums[3] / pixel_count;
-
-            } else if (channels == 3) {
-                uint32_t sum_r = 0, sum_g = 0, sum_b = 0;
-
-                for (int sy = sy_start; sy < sy_end; sy++) {
-                    const uint8_t* src_row = src + sy * src_stride + sx_start * 3;
-                    for (int sx = 0; sx < x_count; sx++) {
-                        const uint8_t* p = src_row + sx * 3;
-                        sum_r += p[0];
-                        sum_g += p[1];
-                        sum_b += p[2];
-                    }
-                }
-
-                uint8_t* out = out_row + dx * 3;
-                out[0] = sum_r / pixel_count;
-                out[1] = sum_g / pixel_count;
-                out[2] = sum_b / pixel_count;
-
-            } else {
-                uint32_t sums[4] = {0, 0, 0, 0};
-
-                for (int sy = sy_start; sy < sy_end; sy++) {
-                    const uint8_t* src_row = src + sy * src_stride + sx_start * channels;
-                    for (int sx = 0; sx < x_count; sx++) {
-                        const uint8_t* p = src_row + sx * channels;
-                        for (int c = 0; c < channels; c++) {
-                            sums[c] += p[c];
-                        }
-                    }
-                }
-
-                uint8_t* out = out_row + dx * channels;
-                for (int c = 0; c < channels; c++) {
-                    out[c] = sums[c] / pixel_count;
-                }
-            }
-        }
-    }
-}
-
-#endif
-
-bool simd_resize(
-    const uint8_t* src, int src_w, int src_h, int channels,
-    uint8_t* dst, int dst_w, int dst_h,
-    ResizeQuality quality
-) {
-    if (!src || !dst || src_w <= 0 || src_h <= 0 ||
-        dst_w <= 0 || dst_h <= 0 || channels < 1 || channels > 4) {
-        return false;
-    }
-
-    if (quality == ResizeQuality::BEST) {
-        return false;
-    }
-
-    float x_scale = (float)src_w / dst_w;
-    float y_scale = (float)src_h / dst_h;
-    float max_scale = std::max(x_scale, y_scale);
-
-#ifdef USE_NEON
-    if (max_scale > 3.0f && (channels == 3 || channels == 4)) {
-        resize_area_neon(src, src_w, src_h, dst, dst_w, dst_h, channels);
-        return true;
-    }
-
-    if (channels == 3 || channels == 4) {
-        resize_bilinear_neon_rgba(src, src_w, src_h, dst, dst_w, dst_h, channels);
-        return true;
-    }
-#endif
-
-    resize_bilinear_scalar(src, src_w, src_h, channels, dst, dst_w, dst_h);
-    return true;
-}
-
-}
-}

data/src/simd_resize.h

@@ -1,72 +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.
- */
-
-#ifndef FASTRESIZE_SIMD_RESIZE_H
-#define FASTRESIZE_SIMD_RESIZE_H
-
-#include <cstddef>
-#include <cstdint>
-
-namespace fastresize {
-namespace internal {
-
-enum class ResizeQuality {
-    FAST,
-    GOOD,
-    BEST
-};
-
-bool simd_resize(
-    const uint8_t* src,
-    int src_w, int src_h,
-    int channels,
-    uint8_t* dst,
-    int dst_w, int dst_h,
-    ResizeQuality quality = ResizeQuality::FAST
-);
-
-inline size_t simd_resize_buffer_size(int dst_w, int dst_h, int channels) {
-    return static_cast<size_t>(dst_w) * dst_h * channels;
-}
-
-}
-}
-
-#endif

data/src/simd_utils.h

@@ -1,127 +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 <cstddef>
-#include <cstdint>
-#include <cstring>
-
-#ifdef __AVX2__
-#include <immintrin.h>
-#endif
-
-#ifdef __ARM_NEON
-#include <arm_neon.h>
-#endif
-
-namespace fastresize {
-namespace internal {
-
-inline void fast_copy_aligned(void* dst, const void* src, size_t size) {
-#ifdef __AVX2__
-    uint8_t* d = (uint8_t*)dst;
-    const uint8_t* s = (const uint8_t*)src;
-    size_t i = 0;
-
-    for (; i + 32 <= size; i += 32) {
-        __m256i data = _mm256_loadu_si256((const __m256i*)(s + i));
-        _mm256_storeu_si256((__m256i*)(d + i), data);
-    }
-
-    for (; i < size; i++) {
-        d[i] = s[i];
-    }
-#elif defined(__ARM_NEON)
-    uint8_t* d = (uint8_t*)dst;
-    const uint8_t* s = (const uint8_t*)src;
-    size_t i = 0;
-
-    for (; i + 16 <= size; i += 16) {
-        uint8x16_t data = vld1q_u8(s + i);
-        vst1q_u8(d + i, data);
-    }
-
-    for (; i < size; i++) {
-        d[i] = s[i];
-    }
-#else
-    memcpy(dst, src, size);
-#endif
-}
-
-inline void fast_copy_pixels(unsigned char* dst, const unsigned char* src,
-                             int width, int height, int channels) {
-    size_t total_bytes = static_cast<size_t>(width) * height * channels;
-    fast_copy_aligned(dst, src, total_bytes);
-}
-
-inline void fast_zero(void* dst, size_t size) {
-#ifdef __AVX2__
-    uint8_t* d = (uint8_t*)dst;
-    size_t i = 0;
-    __m256i zero = _mm256_setzero_si256();
-
-    for (; i + 32 <= size; i += 32) {
-        _mm256_storeu_si256((__m256i*)(d + i), zero);
-    }
-
-    for (; i < size; i++) {
-        d[i] = 0;
-    }
-#elif defined(__ARM_NEON)
-    uint8_t* d = (uint8_t*)dst;
-    size_t i = 0;
-    uint8x16_t zero = vdupq_n_u8(0);
-
-    for (; i + 16 <= size; i += 16) {
-        vst1q_u8(d + i, zero);
-    }
-
-    for (; i < size; i++) {
-        d[i] = 0;
-    }
-#else
-    memset(dst, 0, size);
-#endif
-}
-
-}
-}