基于 C++ 的高性能批量媒体文件压缩程序

class AdaptiveQualityController {
public:
    void adjustBasedOnLoad(const SystemMetrics& metrics) {
        // CPU负载过高时降级质量预设
        if (metrics.cpu_usage > 70.0) {
            current_preset = getFasterPreset(current_preset);
            quality_level = std::max(20, quality_level - 10);
        }
        
        // GPU温度保护
        if (metrics.gpu_temperature > 80.0) {
            enable_thermal_throttling = true;
            reduceEncodingComplexity();
        }
        
        // 内存压力处理
        if (metrics.available_memory < 1024) { // 少于1GB可用内存
            reduceConcurrentTasks();
        }
    }
};

{
    "high_throughput_mode": {
        "target_fps": "max",
        "quality_range": [40, 70],
        "concurrent_tasks": "auto_detect"
    },
    "quality_priority_mode": {
        "target_fps": 30,
        "quality_range": [75, 95],
        "preset": "slow"
    },
    "balanced_mode": {
        "target_fps": 60,
        "quality_range": [50, 80],
        "adaptive_preset": true
    }
}

class ImageCompressor {
private:
    std::unique_ptr<JPEGCompressor> jpeg_compressor_;
    std::unique_ptr<WebPCompressor> webp_compressor_;
    std::unique_ptr<PNGCompressor> png_compressor_;
    AdaptiveQualityController* quality_controller_;
    
public:
    bool compressImage(const std::string& input_path, 
                      const std::string& output_path,
                      int unified_quality_level);
};

class JPEGCompressor {
private:
    tjhandle compress_handle_;
    std::atomic<bool> compression_in_progress_;
    
public:
    JPEGCompressor() {
        compress_handle_ = tjInitCompress();
        // 启用所有可用的SIMD优化
        tjSetScalingFactor(compress_handle_, TJSCALING::TJSCALING_FAST);
    }
    
    CompressionResult compress(const cv::Mat& image, int unified_quality) {
        // 根据统一质量等级映射到具体JPEG质量因子
        int jpeg_quality = mapUnifiedToJPEGQuality(unified_quality);
        
        // 选择速度优化标志
        int flags = TJFLAG_FASTDCT;
        if (unified_quality > 80) {
            flags = TJFLAG_ACCURATEDCT; // 高质量模式使用精确DCT
        }
        
        unsigned char* jpeg_buffer = nullptr;
        unsigned long jpeg_size = 0;
        
        // 执行高性能JPEG压缩
        int result = tjCompress2(compress_handle_,
                               image.data, image.cols, 0, image.rows,
                               TJPF_RGB, &jpeg_buffer, &jpeg_size,
                               TJSAMP_444, jpeg_quality, flags);
        
        CompressionResult comp_result;
        if (result == 0) {
            comp_result.success = true;
            comp_result.compressed_data = std::vector<uchar>(jpeg_buffer, 
                                                           jpeg_buffer + jpeg_size);
            comp_result.actual_quality = jpeg_quality;
            tjFree(jpeg_buffer);
        }
        
        return comp_result;
    }
};

int JPEGCompressor::mapUnifiedToJPEGQuality(int unified_quality) {
    // 严格遵循第三章定义的质量映射表
    static const std::map<int, int> quality_map = {
        {25, 40},  // 低质量
        {50, 75},  // 中等质量  
        {75, 90},  // 高质量
        {95, 98}   // 最高质量
    };
    
    // 查找最接近的质量等级
    auto it = quality_map.lower_bound(unified_quality);
    return (it != quality_map.end()) ? it->second : 75; // 默认中等质量
}

class WebPCompressor {
public:
    CompressionResult compress(const cv::Mat& image, int unified_quality) {
        int webp_quality = mapUnifiedToWebPQuality(unified_quality);
        
        // 配置WebP编码参数
        WebPConfig config;
        WebPConfigPreset(&config, WEBP_PRESET_DEFAULT, webp_quality);
        
        // 根据质量等级调整编码速度
        config.method = (unified_quality > 75) ? 4 : 2; // 高质量使用更慢的编码方法
        
        WebPPicture pic;
        WebPPictureInit(&pic);
        pic.width = image.cols;
        pic.height = image.rows;
        
        // RGB到WebP格式转换
        cv::Mat rgb_image;
        cv::cvtColor(image, rgb_image, cv::COLOR_BGR2RGB);
        pic.argb = (uint32_t*)rgb_image.data;
        
        // 执行WebP编码
        WebPMemoryWriter writer;
        pic.writer = WebPMemoryWrite;
        pic.custom_ptr = &writer;
        
        CompressionResult result;
        if (WebPEncode(&config, &pic)) {
            result.success = true;
            result.compressed_data.assign(writer.mem, writer.mem + writer.size);
            result.actual_quality = webp_quality;
        }
        
        WebPPictureFree(&pic);
        return result;
    }
};

class PNGCompressor {
public:
    CompressionResult compress(const cv::Mat& image, int unified_quality) {
        int png_compression_level = mapUnifiedToPNGLevel(unified_quality);
        
        std::vector<uchar> buffer;
        std::vector<int> params = {cv::IMWRITE_PNG_COMPRESSION, png_compression_level};
        
        CompressionResult result;
        if (cv::imencode(".png", image, buffer, params)) {
            result.success = true;
            result.compressed_data = std::move(buffer);
            result.actual_quality = png_compression_level;
        }
        
        return result;
    }
    
private:
    int mapUnifiedToPNGLevel(int unified_quality) {
        // PNG压缩级别映射（0-9，0=无压缩，9=最大压缩）
        static const std::map<int, int> level_map = {
            {25, 1},  // 低压缩级别，快速处理
            {50, 4},  // 中等压缩级别
            {75, 7},  // 高压缩级别
            {95, 9}   // 最大压缩级别
        };
        
        auto it = level_map.lower_bound(unified_quality);
        return (it != level_map.end()) ? it->second : 4;
    }
};

bool ImageCompressor::compressImage(const std::string& input_path,
                                   const std::string& output_path,
                                   int unified_quality_level) {
    // 检查系统资源状态，必要时自动降级质量
    if (quality_controller_->shouldDegradeQuality()) {
        unified_quality_level = std::max(1, unified_quality_level - 10);
        std::cout << "系统资源紧张，质量自动降级至: " << unified_quality_level << std::endl;
    }
    
    // 根据文件扩展名选择压缩器
    std::string extension = getFileExtension(input_path);
    std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
    
    cv::Mat image = cv::imread(input_path);
    if (image.empty()) {
        return false;
    }
    
    CompressionResult result;
    if (extension == ".jpg" || extension == ".jpeg") {
        result = jpeg_compressor_->compress(image, unified_quality_level);
    } else if (extension == ".webp") {
        result = webp_compressor_->compress(image, unified_quality_level);
    } else if (extension == ".png") {
        result = png_compressor_->compress(image, unified_quality_level);
    }
    
    if (result.success) {
        // 写入压缩后的文件
        std::ofstream outfile(output_path, std::ios::binary);
        outfile.write(reinterpret_cast<const char*>(result.compressed_data.data()),
                     result.compressed_data.size());
        return true;
    }
    
    return false;
}

// 多图像并行压缩示例
void ImageCompressor::compressBatch(const std::vector<std::string>& input_paths,
                                   const std::string& output_dir,
                                   int unified_quality) {
    std::vector<std::future<bool>> futures;
    
    for (const auto& input_path : input_paths) {
        std::string output_path = output_dir + "/compressed_" + 
                                 getFileName(input_path);
        
        futures.push_back(std::async(std::launch::async, [=]() {
            return compressImage(input_path, output_path, unified_quality);
        }));
    }
    
    // 等待所有任务完成
    for (auto& future : futures) {
        future.get();
    }
}

struct CompressionMetrics {
    double compression_ratio;    // 压缩比
    double processing_time_ms;   // 处理时间
    double estimated_quality;    // 估计质量得分
    size_t original_size;        // 原始文件大小
    size_t compressed_size;      // 压缩后大小
};

CompressionMetrics ImageCompressor::calculateMetrics(
    const std::string& input_path, 
    const CompressionResult& result) {
    
    CompressionMetrics metrics;
    metrics.original_size = getFileSize(input_path);
    metrics.compressed_size = result.compressed_data.size();
    metrics.compression_ratio = static_cast<double>(metrics.compressed_size) / 
                               metrics.original_size;
    
    return metrics;
}

class VideoEncoderFactory {
public:
    enum class EncoderPriority {
        NVIDIA_NVENC,    // 最高优先级：专用编码芯片
        INTEL_QSV,       // 次优先级：集成显卡加速
        SOFTWARE_FALLBACK // 降级方案：CPU软编码
    };
    
    std::unique_ptr<BaseVideoEncoder> createEncoder(
        EncoderPriority priority, 
        const EncoderConfig& config) {
        
        // 硬件检测与自动降级
        if (priority == EncoderPriority::NVIDIA_NVENC && 
            hasNvidiaGPU() && checkNVENCSupport()) {
            return std::make_unique<NVENCEncoder>(config);
        }
        else if (priority == EncoderPriority::INTEL_QSV && 
                 hasIntelQuickSync()) {
            return std::make_unique<QSVEncoder>(config);
        }
        else {
            // 硬件不可用时的软件回退
            return std::make_unique<SoftwareEncoder>(config);
        }
    }
};

struct AdaptiveEncodingParams {
    int unified_quality;  // 1-100统一质量等级
    
    // NVIDIA NVENC参数映射
    struct NvencParams {
        int cq_value;      // 21-35范围，质量越高值越小
        const char* preset; // p1-p7，速度优先到质量优先
        bool spatial_aq;   // 空间自适应量化
        bool temporal_aq;  // 时间自适应量化
    };
    
    // Intel QSV参数映射  
    struct QsvParams {
        int target_usage;  // 1-7，1=最佳质量，7=最快速度
        int quality;       // 类似CRF的质量参数
    };
    
    // 软件编码参数映射
    struct SoftwareParams {
        int crf;          // 18-28(H.264)或24-30(H.265)
        const char* preset; // ultrafast-veryslow
    };
    
    // 根据统一质量计算具体参数
    void calculateParams(int unified_quality) {
        this->unified_quality = unified_quality;
        
        // NVENC参数计算
        nvenc_params.cq_value = 35 - (unified_quality * 14 / 100);
        nvenc_params.preset = getNvencPreset(unified_quality);
        nvenc_params.spatial_aq = (unified_quality > 60);
        nvenc_params.temporal_aq = (unified_quality > 70);
        
        // QSV参数计算
        qsv_params.target_usage = 1 + (100 - unified_quality) * 6 / 100;
        qsv_params.quality = 18 + (100 - unified_quality) * 12 / 100;
        
        // 软件编码参数计算
        software_params.crf = 28 - (unified_quality * 10 / 100);
        software_params.preset = getSoftwarePreset(unified_quality);
    }
};

class PerformanceMonitor {
private:
    std::atomic<double> current_cpu_usage{0};
    std::atomic<int> gpu_temperature{0};
    std::atomic<int64_t> available_memory{0};
    std::atomic<double> encoding_fps{0};
    std::atomic<int> frame_drop_count{0};
    
public:
    void startMonitoring() {
        // CPU使用率监控线程
        monitoring_threads_.emplace_back([this]() {
            while (monitoring_active_) {
                current_cpu_usage.store(calculateCPUUsage());
                std::this_thread::sleep_for(100ms);
            }
        });
        
        // GPU温度监控（仅NVIDIA）
        if (hasNvidiaGPU()) {
            monitoring_threads_.emplace_back([this]() {
                while (monitoring_active_) {
                    gpu_temperature.store(getGPUTemperature());
                    std::this_thread::sleep_for(2s);
                }
            });
        }
        
        // 内存使用监控
        monitoring_threads_.emplace_back([this]() {
            while (monitoring_active_) {
                available_memory.store(getAvailableMemory());
                std::this_thread::sleep_for(500ms);
            }
        });
    }
    
    bool shouldAdjustParameters() const {
        // 触发调优的条件判断
        return current_cpu_usage > 70.0 ||    // CPU过载
               gpu_temperature > 80 ||        // GPU过热
               available_memory < 1024 * 1024 * 1024 || // 内存不足1GB
               encoding_fps < target_fps_ * 0.7; // 帧率过低
    }
    
    AdaptiveAdjustment getAdjustment() const {
        AdaptiveAdjustment adjustment;
        
        if (current_cpu_usage > 70.0) {
            adjustment.preset_speedup = 1;  // 提升preset速度等级
            adjustment.crf_increase = 3;    // 适当降低质量
        }
        
        if (gpu_temperature > 80) {
            adjustment.enable_thermal_throttling = true;
            adjustment.max_concurrent_tasks = std::max(1, adjustment.max_concurrent_tasks - 1);
        }
        
        if (available_memory < 512 * 1024 * 1024) { // 内存严重不足
            adjustment.reduce_buffer_size = true;
            adjustment.max_concurrent_tasks = 1; // 单任务处理
        }
        
        return adjustment;
    }
};

class ContentAnalyzer {
public:
    struct ContentFeatures {
        double motion_complexity;    // 运动复杂度 0-1
        double spatial_detail;      // 空间细节丰富度 0-1  
        bool has_text_graphics;     // 是否包含文本图形
        double brightness_variance; // 亮度变化程度
    };
    
    ContentFeatures analyzeFrame(const AVFrame* frame) {
        ContentFeatures features;
        
        // 运动复杂度分析（基于帧间差异）
        features.motion_complexity = calculateMotionComplexity(frame);
        
        // 空间细节分析（基于DCT系数方差）
        features.spatial_detail = calculateSpatialDetail(frame);
        
        // 文本图形检测（基于边缘密度和形状）
        features.has_text_graphics = detectTextAndGraphics(frame);
        
        // 亮度变化分析
        features.brightness_variance = calculateBrightnessVariance(frame);
        
        return features;
    }
    
    ContentBasedAdjustment getAdjustment(const ContentFeatures& features) {
        ContentBasedAdjustment adjustment;
        
        // 高运动场景：适当增加码率，减少B帧数量
        if (features.motion_complexity > 0.7) {
            adjustment.bitrate_multiplier = 1.2;
            adjustment.max_b_frames = 2;
            adjustment.crf_adjustment = -2; // 提高质量
        }
        
        // 高细节场景：使用更精细的量化参数
        if (features.spatial_detail > 0.8) {
            adjustment.enable_adaptive_quantization = true;
            adjustment.crf_adjustment = -1;
        }
        
        // 文本图形内容：禁用B帧，确保清晰度
        if (features.has_text_graphics) {
            adjustment.max_b_frames = 0;
            adjustment.deblocking_filter_strength = 1;
        }
        
        return adjustment;
    }
};

class BatchVideoProcessor {
private:
    moodycamel::ConcurrentQueue<EncodingTask> task_queue_;
    std::vector<std::thread> worker_threads_;
    std::atomic<bool> processing_{false};
    PerformanceMonitor monitor_;
    
public:
    void processBatch(const std::vector<std::string>& input_files,
                     const std::string& output_dir,
                     int unified_quality) {
        
        // 初始化编码器
        auto encoder = encoder_factory_.createEncoder(
            getOptimalEncoderPriority(), 
            EncoderConfig{unified_quality}
        );
        
        // 创建任务队列
        for (const auto& input_file : input_files) {
            EncodingTask task{
                input_file,
                output_dir + "/" + getOutputFilename(input_file),
                unified_quality
            };
            task_queue_.enqueue(task);
        }
        
        // 启动工作线程
        size_t num_workers = calculateOptimalWorkerCount();
        worker_threads_.reserve(num_workers);
        
        for (size_t i = 0; i < num_workers; ++i) {
            worker_threads_.emplace_back([this, encoder]() {
                processWorker(encoder);
            });
        }
        
        // 启动性能监控
        monitor_.startMonitoring();
        processing_.store(true);
        
        // 等待任务完成
        while (!task_queue_.empty() && processing_.load()) {
            std::this_thread::sleep_for(100ms);
            
            // 实时性能调整
            if (monitor_.shouldAdjustParameters()) {
                auto adjustment = monitor_.getAdjustment();
                applyPerformanceAdjustment(adjustment);
            }
        }
        
        // 清理资源
        processing_.store(false);
        for (auto& worker : worker_threads_) {
            if (worker.joinable()) worker.join();
        }
    }
    
private:
    void processWorker(std::shared_ptr<BaseVideoEncoder> encoder) {
        EncodingTask task;
        
        while (processing_.load() && task_queue_.try_dequeue(task)) {
            try {
                // 执行视频压缩
                auto result = encoder->encodeVideo(
                    task.input_path, 
                    task.output_path, 
                    task.unified_quality
                );
                
                // 记录处理结果
                logProcessingResult(task, result);
                
            } catch (const std::exception& e) {
                // 错误处理与降级
                handleEncodingError(task, e);
            }
        }
    }
    
    size_t calculateOptimalWorkerCount() const {
        // 基于系统资源和文件大小计算最优并发数
        size_t cpu_cores = std::thread::hardware_concurrency();
        size_t memory_based = getAvailableMemory() / (512 * 1024 * 1024); // 每任务512MB
        size_t file_based = std::min(size_t(8), input_files_.size() / 2);
        
        return std::min({cpu_cores, memory_based, file_based, size_t(16)});
    }
};

class ErrorHandler {
public:
    enum class ErrorSeverity {
        WARNING,      // 可恢复错误
        RECOVERABLE,  // 需要降级处理
        FATAL         // 任务失败
    };
    
    ErrorSeverity classifyError(const std::exception& e) {
        const std::string msg = e.what();
        
        // 硬件编码器初始化失败
        if (msg.find("NVENC") != std::string::npos || 
            msg.find("QSV") != std::string::npos) {
            return ErrorSeverity::RECOVERABLE;
        }
        
        // 内存不足错误
        if (msg.find("memory") != std::string::npos ||
            msg.find("alloc") != std::string::npos) {
            return ErrorSeverity::RECOVERABLE;
        }
        
        // 文件I/O错误
        if (msg.find("file") != std::string::npos ||
            msg.find("IO") != std::string::npos) {
            return ErrorSeverity::FATAL;
        }
        
        return ErrorSeverity::WARNING;
    }
    
    bool handleError(EncodingTask& task, const std::exception& e) {
        auto severity = classifyError(e);
        
        switch (severity) {
            case ErrorSeverity::WARNING:
                logger_.warn("任务 {} 警告: {}", task.input_path, e.what());
                return true; // 继续处理
                
            case ErrorSeverity::RECOVERABLE:
                logger_.info("任务 {} 降级处理: {}", task.input_path, e.what());
                return attemptRecovery(task, e);
                
            case ErrorSeverity::FATAL:
                logger_.error("任务 {} 失败: {}", task.input_path, e.what());
                return false; // 任务终止
        }
    }
    
private:
    bool attemptRecovery(EncodingTask& task, const std::exception& e) {
        // 硬件编码器失败时降级到软件编码
        if (std::string(e.what()).find("encoder") != std::string::npos) {
            logger_.info("降级到软件编码器处理: {}", task.input_path);
            return fallbackToSoftwareEncoder(task);
        }
        
        // 内存不足时减少并发任务
        if (std::string(e.what()).find("memory") != std::string::npos) {
            reduceConcurrentTasks();
            std::this_thread::sleep_for(1s); // 等待资源释放
            return requeueTask(task); // 重新排队
        }
        
        return false;
    }
};

size_t calculate_optimal_threads() {
    size_t cpu_cores = std::thread::hardware_concurrency();
    size_t available_memory_mb = get_system_memory() / 1024 / 1024;
    size_t memory_based_threads = available_memory_mb / 512;  // 每任务512MB内存预算
    size_t file_based_threads = pending_files.size() / 2;
    
    return std::min({cpu_cores, memory_based_threads, file_based_threads, (size_t)16});
}

void distribute_gpu_load() {
    auto gpu_status = get_gpu_utilization();
    for (auto& gpu : gpu_status) {
        if (gpu.utilization < 60% && gpu.temperature < 75℃) {
            assign_new_tasks(gpu.id, calculate_gpu_capacity(gpu));
        }
    }
}

// 自适应质量调节核心逻辑
void AdaptiveQualityOptimizer::adjustParameters(const PerformanceMetrics& metrics) {
    double ratio_error = target_compression_ratio - actual_compression_ratio;
    double time_error = (max_processing_time_ms - actual_processing_time_ms) / max_processing_time_ms;
    
    // PID式调节：根据误差调整质量参数
    double adjustment = ratio_error * 10 + time_error * 5;
    current_quality = std::max(10.0, std::min(100.0, current_quality + adjustment));
}

int optimal_threads = std::min({
    std::thread::hardware_concurrency(),
    static_cast<int>(available_memory / 512),  // 每线程预留512MB
    std::max(1, static_cast<int>(file_count / 2)),
    16  // 最大线程数限制
});

class MediaCompressor {
public:
    // 单文件压缩接口
    static CompressionResult compressImage(const std::string& input_path,
                                          const std::string& output_path,
                                          int quality_level = 75);
    
    static CompressionResult encodeVideo(const std::string& input_path,
                                        const std::string& output_path,
                                        int quality_level = 75,
                                        const std::string& encoder_preference = "auto");
    
    // 批量处理接口
    static BatchResult compressBatch(const std::vector<std::string>& input_files,
                                    const std::string& output_dir,
                                    int quality_level = 75,
                                    int max_concurrent = 0);
    
    // 实时监控接口
    static PerformanceMetrics getCurrentMetrics();
    static bool registerProgressCallback(ProgressCallback callback);
};

struct CompressionConfig {
    int quality_level;           // 1-100归一化质量参数
    std::string output_format;   // 自动推断或指定格式
    bool enable_hardware_accel;  // 硬件加速开关
    int max_threads;            // 最大并发线程数
    AdaptiveMode adaptive_mode;  // 质量/速度优先模式
};

struct CompressionResult {
    bool success;
    std::string output_path;
    double compression_ratio;
    double processing_time_ms;
    int actual_quality_used;
    std::string error_message;
};

#include "media_compressor.h"

// 图像压缩示例
void compressSingleImage() {
    CompressionResult result = MediaCompressor::compressImage(
        "input.jpg", 
        "output.jpg", 
        85  // 高质量压缩
    );
    
    if (result.success) {
        std::cout << "压缩成功: " << result.output_path << std::endl;
        std::cout << "压缩比: " << result.compression_ratio 
                  << ", 耗时: " << result.processing_time_ms << "ms" << std::endl;
    }
}

// 视频压缩示例
void compressSingleVideo() {
    CompressionResult result = MediaCompressor::encodeVideo(
        "input.mp4",
        "output.mp4",
        75,     // 平衡质量
        "nvenc" // 优先使用NVENC硬件编码
    );
}

// 自定义配置批量处理
void advancedBatchCompression() {
    std::vector<std::string> image_files = {
        "photo1.jpg", "photo2.png", "screenshot.webp"
    };
    
    std::vector<std::string> video_files = {
        "video1.mp4", "video2.mov", "presentation.avi"
    };
    
    // 图像批量处理（4线程并发）
    BatchResult image_result = MediaCompressor::compressBatch(
        image_files, "./compressed_images/", 80, 4
    );
    
    // 视频批量处理（自动检测最优并发数）
    BatchResult video_result = MediaCompressor::compressBatch(
        video_files, "./compressed_videos/", 70
    );
    
    // 注册进度回调
    MediaCompressor::registerProgressCallback([](const ProgressInfo& info) {
        std::cout << "进度: " << info.percentage << "%, "
                  << "剩余时间: " << info.remaining_time << "s" << std::endl;
    });
}

// 性能监控示例
void monitorCompressionProcess() {
    // 获取实时性能指标
    PerformanceMetrics metrics = MediaCompressor::getCurrentMetrics();
    
    std::cout << "CPU使用率: " << metrics.cpu_usage << "%" << std::endl;
    std::cout << "GPU温度: " << metrics.gpu_temperature << "°C" << std::endl;
    std::cout << "内存使用: " << metrics.memory_usage_mb << "MB" << std::endl;
    std::cout << "实时吞吐量: " << metrics.throughput_fps << "FPS" << std::endl;
    
    // 基于监控结果动态调整
    if (metrics.gpu_temperature > 80) {
        std::cout << "GPU温度过高，建议降低质量或减少并发任务" << std::endl;
    }
}

# 基本语法
media_compressor -i <input> -o <output> -q <quality> [options]

# 图像压缩示例
media_compressor -i input.jpg -o output.jpg -q 85
media_compressor -i photo.png -o compressed.webp -q 75 --format webp

# 视频压缩示例
media_compressor -i video.mp4 -o compressed.mp4 -q 70 --encoder nvenc
media_compressor -i movie.mov -o output.mov -q 80 --preset balanced

# 批量压缩整个目录
media_compressor -i ./videos/ -o ./compressed/ -q 75 --recursive

# 指定文件类型批量处理
media_compressor -i ./photos/ -o ./output/ -q 85 --extensions jpg,png,webp

# 带并发控制的批量处理
media_compressor -i ./large_dataset/ -o ./result/ -q 70 --threads 8 --max-memory 4096

# 质量-速度自适应模式
media_compressor -i input.mp4 -o output.mp4 --adaptive-mode quality-priority
media_compressor -i input.jpg -o output.jpg --adaptive-mode speed-priority

# 硬件加速控制
media_compressor -i video.mov -o output.mov --hardware-accel auto
media_compressor -i video.avi -o output.avi --hardware-accel nvenc --gpu-temperature-limit 75

# 性能监控输出
media_compressor -i big_file.mp4 -o compressed.mp4 -q 80 --monitor --stats-interval 1000

{
    "compression_profiles": {
        "high_quality": {
            "quality_level": 90,
            "adaptive_mode": "quality_priority",
            "encoder_preference": ["nvenc", "qsv", "software"],
            "max_threads": 4
        },
        "fast_processing": {
            "quality_level": 60,
            "adaptive_mode": "speed_priority", 
            "encoder_preference": ["qsv", "nvenc", "software"],
            "max_threads": 8
        },
        "balanced": {
            "quality_level": 75,
            "adaptive_mode": "balanced",
            "encoder_preference": "auto",
            "max_threads": 6
        }
    },
    "system_limits": {
        "max_concurrent_tasks": 16,
        "gpu_temperature_limit": 80,
        "max_memory_usage_mb": 8192,
        "cpu_usage_threshold": 85
    },
    "output_settings": {
        "default_format": "auto",
        "overwrite_existing": false,
        "create_subdirectories": true
    }
}

# 使用配置文件
media_compressor -i input.mp4 -o output.mp4 --config high_quality_profile.json

# 命令行参数覆盖配置
media_compressor -i video.mov -o compressed.mov --config balanced.json -q 85

enum class CompressionError {
    SUCCESS = 0,
    FILE_NOT_FOUND = 1,
    UNSUPPORTED_FORMAT = 2,
    HARDWARE_UNAVAILABLE = 3,
    INSUFFICIENT_MEMORY = 4,
    QUALITY_OUT_OF_RANGE = 5,
    ENCODING_TIMEOUT = 6,
    TEMPERATURE_LIMIT_EXCEEDED = 7
};

try {
    CompressionResult result = MediaCompressor::compressImage(
        "input.jpg", "output.jpg", 120  // 无效质量值
    );
} catch (const CompressionException& e) {
    switch (e.getErrorCode()) {
        case CompressionError::QUALITY_OUT_OF_RANGE:
            std::cerr << "质量参数超出范围(1-100): " << e.what() << std::endl;
            break;
        case CompressionError::FILE_NOT_FOUND:
            std::cerr << "输入文件不存在: " << e.what() << std::endl;
            break;
        default:
            std::cerr << "压缩错误: " << e.what() << std::endl;
    }
}

cmake_minimum_required(VERSION 3.10)
project(MyMediaApp)

find_package(MediaCompressor REQUIRED)

add_executable(my_app main.cpp)
target_link_libraries(my_app MediaCompressor::media_compressor)

#include <media_compressor.h>
#include <iostream>
#include <vector>

class MyMediaProcessor {
public:
    void processUserRequest(const std::string& input_dir, 
                          const std::string& output_dir,
                          int desired_quality) {
        
        // 自动检测文件类型并分类处理
        auto [image_files, video_files] = scanDirectory(input_dir);
        
        // 并行处理图像和视频
        std::thread image_thread([&]() {
            processImages(image_files, output_dir, desired_quality);
        });
        
        std::thread video_thread([&]() {
            processVideos(video_files, output_dir, desired_quality);
        });
        
        image_thread.join();
        video_thread.join();
        
        std::cout << "批量处理完成!" << std::endl;
    }

private:
    void processImages(const std::vector<std::string>& files,
                      const std::string& output_dir,
                      int quality) {
        BatchResult result = MediaCompressor::compressBatch(
            files, output_dir, quality, 4
        );
        
        printBatchStats(result, "图像");
    }
    
    void processVideos(const std::vector<std::string>& files,
                      const std::string& output_dir,
                      int quality) {
        BatchResult result = MediaCompressor::compressBatch(
            files, output_dir, quality, 2  // 视频处理并发数较低
        );
        
        printBatchStats(result, "视频");
    }
    
    void printBatchStats(const BatchResult& result, const std::string& type) {
        std::cout << type << "处理统计:" << std::endl;
        std::cout << "  成功: " << result.success_count << " 文件" << std::endl;
        std::cout << "  失败: " << result.failure_count << " 文件" << std::endl;
        std::cout << "  平均压缩比: " << result.average_compression_ratio << std::endl;
        std::cout << "  总耗时: " << result.total_processing_time << "ms" << std::endl;
    }
};