C++ 版轻量级图片解析程序

文件读取层 → 格式分发层 → 并行解码层 → 元数据提取层 → 结果输出层

-O3 -march=native -ffast-math -fno-exceptions

# CMakeLists.txt关键配置
set(TURBOJPEG_STATIC TRUE)  # 静态链接减少运行时依赖
add_definitions(-DJPEG_TURBO_SSE2)  # 显式启用SSE2优化

// 嵌入式模式内存限制
png_set_compression_buffer_size(png_ptr, 8192);  // 8KB压缩缓冲区
png_set_user_limits(png_ptr, 8192, 8192);  // 限制最大分辨率

#define STBI_NO_SIMD           // 禁用内置SIMD（使用外部优化）
#define STBI_MALLOC custom_malloc  // 自定义内存分配器
#define STBI_FREE custom_free
#include "stb_image.h"

libjpeg-turbo >= 2.1.0  # SIMD加速JPEG
libpng >= 1.6.0         # 官方PNG实现
stb_image.h             # 单文件WebP/BMP支持

#pragma pack(push, 1)  // 紧凑内存对齐
struct ImageMetaData {
    uint32_t width;           // 图像宽度
    uint32_t height;          // 图像高度
    uint8_t channels;         // 通道数：1(灰度)/3(RGB)/4(RGBA)
    uint8_t bit_depth;        // 色深：8/16位
    uint8_t format;           // 格式标识：JPEG=0, PNG=1, BMP=2, WebP=3
    uint8_t status_flags;     // 状态位：超时|内存超限|解码错误
    uint64_t file_size;       // 原始文件大小（字节）
    uint32_t decode_time_ms;  // 解码耗时（毫秒）
};
#pragma pack(pop)  // 恢复默认对齐

class PixelBuffer {
private:
    static constexpr uint32_t BLOCK_SIZE = 1024 * 1024;  // 1MB分块
    std::vector<std::unique_ptr<uint16_t[]>> blocks_;    // RGB565数据块
    uint32_t width_, height_;
    uint8_t* custom_allocator_ptr_;  // 指向全局内存池

public:
    // 自定义分配器接口（对接前文100MB预分配池）
    void* allocateBlock(size_t size) {
        return custom_allocator_ptr_->allocateAligned(size, 64);
    }
    
    // 分块访问接口（支持SIMD优化）
    uint16_t* getBlock(uint32_t block_x, uint32_t block_y) const {
        uint32_t block_index = (block_y * ((width_ + 1023) / 1024)) + block_x;
        return blocks_[block_index].get();
    }
};

struct ProcessingTask {
    ImageMetaData metadata;          // 元数据（64字节）
    PixelBuffer pixel_data;          // 像素缓冲区（智能指针管理）
    std::atomic<uint32_t> ref_count;  // 无锁引用计数
    moodycamel::ProducerToken token; // 无锁队列生产者令牌
    
    // 格式分发路由（前文格式分发层）
    DecoderType getDecoderType() const {
        switch(metadata.format) {
            case 0: return DecoderType::LIBJPEG_TURBO;
            case 1: return DecoderType::LIBPNG;  
            case 2: // BMP
            case 3: // WebP
                return DecoderType::STB_IMAGE;
        }
    }
};

class FixedSizeMemoryPool {
private:
    std::vector<void*> chunks_;       // 预分配的大内存块
    std::stack<void*> free_blocks_;   // 空闲块栈（LIFO优化缓存局部性）
    size_t block_size_;               // 固定块大小（64字节对齐）
    size_t total_capacity_;          // 总容量上限（100 MB）
    std::atomic<size_t> used_memory_; // 原子内存使用计数器
    std::mutex pool_mutex_;           // 池级互斥锁（避免过度无锁化）
    
public:
    FixedSizeMemoryPool(size_t block_size, size_t num_blocks) 
        : block_size_(align64(block_size)), 
          total_capacity_(block_size_ * num_blocks),
          used_memory_(0) {
        // 启动时一次性预分配（避免运行时碎片）
        allocate_chunk(total_capacity_);
    }
    
    void* allocate() {
        std::lock_guard<std::mutex> lock(pool_mutex_);
        if (free_blocks_.empty()) {
            if (used_memory_.load() + block_size_ > total_capacity_) {
                return nullptr; // 触发内存警戒线
            }
            // 从大块中切分新块（保持64字节对齐）
            void* new_block = split_from_chunk();
            free_blocks_.push(new_block);
        }
        void* block = free_blocks_.top();
        free_blocks_.pop();
        used_memory_.fetch_add(block_size_);
        return block;
    }
    
    void deallocate(void* ptr) {
        std::lock_guard<std::mutex> lock(pool_mutex_);
        free_blocks_.push(ptr);
        used_memory_.fetch_sub(block_size_);
    }
};

class GlobalMemoryMonitor {
    static constexpr size_t MEMORY_THRESHOLD = 1200 * 1024 * 1024; // 1.2 GB
public:
    bool check_memory_safe() {
        auto current_usage = get_system_memory_usage();
        if (current_usage > MEMORY_THRESHOLD) {
            ImageMetaData::status_flags |= MEMORY_OVERFLOW;
            return false;
        }
        return true;
    }
};

class DualStageThreadPool {
private:
    // I/O线程池：单线程专用于文件读写
    moodycamel::ConcurrentQueue<IO_Task> io_queue_;
    std::thread io_thread_;
    
    // 计算线程池：严格匹配2个物理核心
    moodycamel::ConcurrentQueue<ProcessingTask> compute_queue_;
    std::array<std::thread, 2> compute_threads_;  // 固定2线程
    
    std::atomic<bool> shutdown_{false};
    
public:
    DualStageThreadPool() {
        // I/O线程初始化
        io_thread_ = std::thread([this] {
            IO_Task task;
            while (!shutdown_.load(std::memory_order_acquire)) {
                if (io_queue_.try_dequeue(task)) {
                    load_image_data(task); // 非阻塞I/O操作
                    route_to_compute_pool(task); // 任务路由
                }
                std::this_thread::yield(); // 主动让出CPU
            }
        });
        
        // 计算线程初始化（绑定特定CPU核心）
        for (int i = 0; i < 2; ++i) {
            compute_threads_[i] = std::thread([this, i] {
                set_thread_affinity(i); // 绑定到核心0和核心1
                ProcessingTask task;
                while (!shutdown_.load(std::memory_order_acquire)) {
                    if (compute_queue_.try_dequeue(task)) {
                        process_image_task(task);
                    }
                    std::this_thread::yield();
                }
            });
        }
    }
};

class TaskDispatcher {
private:
    moodycamel::ConcurrentQueue<ProcessingTask> queue_;
    moodycamel::ProducerTokens tokens_[3]; // I/O线程+2计算线程
    
public:
    void submit_task(ProcessingTask&& task) {
        // 根据解码器类型路由到对应队列
        auto decoder_type = task.getDecoderType();
        queue_.enqueue(tokens_[decoder_type], std::move(task));
    }
    
    // 工作窃取支持：空闲线程可从其他线程队列窃取任务
    bool steal_work(ProcessingTask& task, int thief_id) {
        for (int i = 0; i < 3; ++i) {
            if (i != thief_id && queue_.try_dequeue_from_producer(tokens_[i], task)) {
                return true;
            }
        }
        return false;
    }
};

class PixelBufferAllocator {
private:
    FixedSizeMemoryPool& pool_; // 引用全局内存池
    
public:
    void* allocate(size_t size) {
        if (!GlobalMemoryMonitor::check_memory_safe()) {
            return nullptr; // 内存超限，分配失败
        }
        
        // 强制64字节对齐，满足SIMD要求
        size_t aligned_size = align64(size);
        void* memory = pool_.allocate(aligned_size);
        
        if (memory == nullptr) {
            ImageMetaData::status_flags |= ALLOCATION_FAILED;
        }
        return memory;
    }
    
    void deallocate(void* ptr, size_t size) {
        pool_.deallocate(ptr);
    }
};

struct ProcessingTask {
    std::atomic<uint32_t> ref_count{1};
    PixelBuffer* buffer;
    
    void retain() { ref_count.fetch_add(1, std::memory_order_relaxed); }
    
    void release() {
        if (ref_count.fetch_sub(1, std::memory_order_acq_rel) == 1) {
            // 最后一个引用，安全释放内存
            if (buffer && buffer->custom_allocator_ptr_) {
                buffer->custom_allocator_ptr_->deallocate(buffer->data, buffer->size);
            }
            delete this;
        }
    }
};

// AVX2优化的YUV到RGB565转换
void yuv_to_rgb565_avx2(const uint8_t* y_plane, const uint8_t* u_plane, 
                       const uint8_t* v_plane, uint16_t* rgb_output, size_t pixel_count) {
    // 加载YUV系数到AVX2寄存器
    const __m256i y_bias = _mm256_set1_epi16(16);
    const __m256i rgb_scale = _mm256_set1_epi16(255);
    
    for(size_t i = 0; i < pixel_count; i += 16) {
        // 并行加载16个YUV像素
        __m256i y_values = _mm256_load_si256((const __m256i*)(y_plane + i));
        __m256i u_values = _mm256_load_si256((const __m256i*)(u_plane + i/2));
        __m256i v_values = _mm256_load_si256((const __m256i*)(v_plane + i/2));
        
        // SIMD转换计算（省略详细转换矩阵）
        __m256i r, g, b;
        // ... AVX2向量运算实现完整的YUV→RGB转换
        
        // 打包为RGB565格式
        __m256i rgb565 = _mm256_or_si256(
            _mm256_slli_epi16(r, 11),
            _mm256_or_si256(_mm256_slli_epi16(g, 5), b)
        );
        
        // 对齐存储到预分配缓冲区
        _mm256_store_si256((__m256i*)(rgb_output + i), rgb565);
    }
}

// SSE4.1优化的端序转换（处理8像素/批次）
void endian_swap_sse41(uint16_t* pixels, size_t count) {
    for(size_t i = 0; i < count; i += 8) {
        __m128i data = _mm_load_si128((const __m128i*)(pixels + i));
        // 交换高低字节：ABCD -> BADC
        __m128i swapped = _mm_or_si128(
            _mm_slli_epi16(data, 8),
            _mm_srli_epi16(data, 8)
        );
        _mm_store_si128((__m128i*)(pixels + i), swapped);
    }
}

// NEON优化的Alpha预乘（ARM平台）
void alpha_premultiply_neon(uint16_t* rgba_pixels, size_t pixel_count) {
    for(size_t i = 0; i < pixel_count; i += 8) {
        uint16x8_t pixels = vld1q_u16(rgba_pixels + i);
        
        // 提取Alpha通道并归一化
        uint16x8_t alpha = vandq_u16(pixels, vdupq_n_u16(0x1F));  // RGB565A格式
        uint16x8_t norm_alpha = vshrq_n_u16(alpha, 3);  // 5bit→8bit归一化
        
        // 并行Alpha预乘计算
        uint16x8_t multiplied = vmulq_u16(pixels, norm_alpha);
        multiplied = vshrq_n_u16(multiplied, 8);  // 重新缩放
        
        vst1q_u16(rgba_pixels + i, multiplied);
    }
}

// 指令集分派逻辑
void dispatch_pixel_operation(PixelOperation op, void* data, size_t size) {
    if(cpu_supports_avx2()) {
        avx2_implementation(op, data, size);
    } else if(cpu_supports_sse41()) {
        sse41_implementation(op, data, size);
    } else {
        scalar_implementation(op, data, size);  // 保底实现
    }
}

class JPEGTurboDecoder : public IDecoder {
private:
    jpeg_decompress_struct cinfo_;
    jpeg_error_mgr jerr_;
    PixelBufferAllocator& allocator_;
    
public:
    explicit JPEGTurboDecoder(PixelBufferAllocator& alloc) 
        : allocator_(alloc) {
        cinfo_.err = jpeg_std_error(&jerr_);
        jpeg_create_decompress(&cinfo_);
    }
    
    bool decode(const uint8_t* data, size_t size,
                PixelBuffer& out, ImageMetaData& meta) override;
    
    DecoderType type() const noexcept override { 
        return DecoderType::LIBJPEG_TURBO; 
    }
    
    ~JPEGTurboDecoder() {
        jpeg_destroy_decompress(&cinfo_);
    }
};

bool JPEGTurboDecoder::decode(const uint8_t* data, size_t size,
                              PixelBuffer& out, ImageMetaData& meta) {
    // 设置内存限制和超时检测
    cinfo_.mem->max_memory_to_use = 50 * 1024 * 1024; // 50MB硬限
    auto start_time = std::chrono::high_resolution_clock::now();
    
    jpeg_mem_src(&cinfo_, data, size);
    jpeg_read_header(&cinfo_, TRUE);
    
    // 强制输出RGB格式，确保与SIMD后处理兼容
    cinfo_.out_color_space = JCS_RGB;
    jpeg_start_decompress(&cinfo_);
    
    // 通过内存池分配对齐缓冲区
    out = allocator_.allocate(cinfo_.output_width, 
                             cinfo_.output_height, 3);
    
    // 行缓冲解码，支持超时中断
    while (cinfo_.output_scanline < cinfo_.output_height) {
        auto elapsed = std::chrono::high_resolution_clock::now() - start_time;
        if (std::chrono::duration_cast<std::chrono::milliseconds>(elapsed) > 
            std::chrono::milliseconds(100)) {
            meta.status_flags |= DECODE_TIMEOUT;
            jpeg_abort_decompress(&cinfo_);
            return false;
        }
        
        uint8_t* row_ptr = out.data + 
                          cinfo_.output_scanline * cinfo_.output_width * 3;
        jpeg_read_scanlines(&cinfo_, &row_ptr, 1);
    }
    
    jpeg_finish_decompress(&cinfo_);
    meta.decode_time_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
        std::chrono::high_resolution_clock::now() - start_time).count();
    
    return GlobalMemoryMonitor::check_memory_safe();
}

class PNGDecoder : public IDecoder {
private:
    png_structp png_ptr_;
    png_infop info_ptr_;
    bool embedded_mode_;
    
public:
    PNGDecoder(bool embedded = true) : embedded_mode_(embedded) {
        png_ptr_ = png_create_read_struct(PNG_LIBPNG_VER_STRING, 
                                         nullptr, nullptr, nullptr);
        if (embedded_mode_) {
            // 启用512KB嵌入式模式，减少内存碎片
            png_set_user_limits(png_ptr_, 8192, 8192); // 最大8K分辨率
        }
    }
};

// 设置行缓冲回调，实现内存可控的渐进式解码
png_set_read_fn(png_ptr_, this, [](png_structp png, png_bytep data, png_size_t length) {
    auto* decoder = static_cast<PNGDecoder*>(png_get_io_ptr(png));
    decoder->stream_read(data, length);
});

// 逐行处理，支持超时检查
for (int y = 0; y < height; ++y) {
    if (check_timeout(start_time, 150)) {
        meta.status_flags |= DECODE_TIMEOUT;
        break;
    }
    png_read_row(png_ptr_, row_buffer, nullptr);
    process_row_with_simd(row_buffer, out.data + y * row_stride);
}

class StbImageDecoder : public IDecoder {
private:
    static void* stbi_alloc(size_t size) {
        return PixelBufferAllocator::global().allocate_raw(size, 64);
    }
    
    static void stbi_free(void* ptr) {
        PixelBufferAllocator::global().deallocate_raw(ptr);
    }
    
public:
    StbImageDecoder() {
        // 禁用内置SIMD，使用外部优化版本
        stbi_set_unpremultiply_on_load(1);
        stbi_convert_iphone_png_to_rgb(0);
        
        // 重定向内存分配器
        stbi_set_mem_allocators(stbi_alloc, stbi_free);
    }
    
    bool decode(const uint8_t* data, size_t size,
                PixelBuffer& out, ImageMetaData& meta) override {
        int width, height, channels;
        
        // 强制RGB输出，确保格式统一
        unsigned char* pixels = stbi_load_from_memory(
            data, size, &width, &height, &channels, STBI_rgb);
            
        if (!pixels) {
            meta.status_flags |= DECODE_ERROR;
            return false;
        }
        
        // 内存池接管分配的内存
        out = allocator_.wrap_existing(pixels, width, height, 3);
        return true;
    }
};

// 解码器状态到系统状态标志的映射
switch (decoder_specific_error) {
    case JPEG_TURBO_ERR_MEMORY:
        meta.status_flags |= ALLOCATION_FAILED;
        break;
    case PNG_ERR_TIMEOUT:
        meta.status_flags |= DECODE_TIMEOUT;
        break;
    case STBI_ERR_FORMAT:
        meta.status_flags |= UNSUPPORTED_FORMAT;
        break;
}

// RAII包装确保资源释放
class DecoderGuard {
    IDecoder* decoder_;
    PixelBuffer& buffer_;
    
public:
    DecoderGuard(IDecoder* dec, PixelBuffer& buf) 
        : decoder_(dec), buffer_(buf) {}
        
    ~DecoderGuard() {
        if (decoder_ && buffer_.data) {
            GlobalMemoryMonitor::release_buffer(buffer_);
        }
    }
};

int main(int argc, char* argv[]) {
    // 1. 系统初始化与资源预分配
    GlobalMemoryMonitor::initialize();  // 启动内存监控
    PixelBufferAllocator::preallocate(100 * 1024 * 1024);  // 预分配100MB内存池
    
    // 2. 双线程池启动（I/O线程+计算线程）
    DualStageThreadPool pool(1, 2);  // 1个I/O线程，2个计算线程
    pool.bind_threads_to_cores();    // 线程绑定到物理核心
    
    // 3. 解码器工厂初始化
    DecoderFactory::register_decoders();
    
    // 4. 主循环：文件扫描→任务分发→结果收集
    process_image_batch(argv[1], pool);
    
    // 5. 优雅关闭
    pool.shutdown();
    return 0;
}

文件扫描层 → 格式分发层 → 并行解码层 → 元数据提取层 → 结果输出层
    ↓           ↓           ↓           ↓           ↓
 I/O线程    主线程      计算线程0/1    计算线程     主线程