graphics_optimizer.h

Go to the documentation of this file.

#ifndef YAZE_APP_GFX_GRAPHICS_OPTIMIZER_H
#define YAZE_APP_GFX_GRAPHICS_OPTIMIZER_H
 
#include <vector>
#include <unordered_map>
#include <string>
 
#include "app/gfx/bpp_format_manager.h"
#include "app/gfx/performance/performance_profiler.h"
 
namespace yaze {
namespace gfx {
 
enum class OptimizationStrategy {
  kMemoryOptimized,    
  kPerformanceOptimized, 
  kQualityOptimized,   
  kBalanced           
};
 
struct OptimizationResult {
  bool success;
  std::string message;
  size_t memory_saved;
  float performance_gain;
  float quality_loss;
  std::vector<BppFormat> recommended_formats;
  std::unordered_map<int, BppFormat> sheet_recommendations;
  
  OptimizationResult() : success(false), memory_saved(0), performance_gain(0.0f), quality_loss(0.0f) {}
};
 
struct SheetOptimizationData {
  int sheet_id;
  BppFormat current_format;
  BppFormat recommended_format;
  size_t current_size;
  size_t optimized_size;
  float compression_ratio;
  int colors_used;
  bool is_convertible;
  std::string optimization_reason;
  
  SheetOptimizationData() : sheet_id(-1), current_format(BppFormat::kBpp8),
                           recommended_format(BppFormat::kBpp8), current_size(0),
                           optimized_size(0), compression_ratio(1.0f), colors_used(0),
                           is_convertible(false) {}
};
 
class GraphicsOptimizer {
 public:
  static GraphicsOptimizer& Get();
  
  void Initialize();
  
  OptimizationResult OptimizeSheet(const std::vector<uint8_t>& sheet_data,
                                  int sheet_id,
                                  const SnesPalette& palette,
                                  OptimizationStrategy strategy = OptimizationStrategy::kBalanced);
  
  OptimizationResult OptimizeSheets(const std::unordered_map<int, std::vector<uint8_t>>& sheets,
                                   const std::unordered_map<int, SnesPalette>& palettes,
                                   OptimizationStrategy strategy = OptimizationStrategy::kBalanced);
  
  SheetOptimizationData AnalyzeSheet(const std::vector<uint8_t>& sheet_data,
                                    int sheet_id,
                                    const SnesPalette& palette);
  
  std::unordered_map<int, SheetOptimizationData> GetOptimizationRecommendations(
      const std::unordered_map<int, std::vector<uint8_t>>& sheets,
      const std::unordered_map<int, SnesPalette>& palettes);
  
  OptimizationResult ApplyOptimizations(
      const std::unordered_map<int, SheetOptimizationData>& recommendations,
      std::unordered_map<int, std::vector<uint8_t>>& sheets,
      std::unordered_map<int, SnesPalette>& palettes);
  
  std::unordered_map<std::string, double> GetOptimizationStats() const;
  
  void ClearCache();
  
  void SetOptimizationParameters(float max_quality_loss = 0.1f,
                                size_t min_memory_savings = 1024,
                                float performance_threshold = 0.05f);
 
 private:
  GraphicsOptimizer() = default;
  ~GraphicsOptimizer() = default;
  
  // Optimization parameters
  float max_quality_loss_;
  size_t min_memory_savings_;
  float performance_threshold_;
  
  // Statistics tracking
  std::unordered_map<std::string, double> optimization_stats_;
  
  // Cache for optimization results
  std::unordered_map<std::string, SheetOptimizationData> optimization_cache_;
  
  // Helper methods
  BppFormat DetermineOptimalFormat(const std::vector<uint8_t>& data,
                                  const SnesPalette& palette,
                                  OptimizationStrategy strategy);
  float CalculateQualityLoss(BppFormat from_format, BppFormat to_format,
                            const std::vector<uint8_t>& data);
  size_t CalculateMemorySavings(BppFormat from_format, BppFormat to_format,
                               const std::vector<uint8_t>& data);
  float CalculatePerformanceGain(BppFormat from_format, BppFormat to_format);
  bool ShouldOptimize(const SheetOptimizationData& data, OptimizationStrategy strategy);
  std::string GenerateOptimizationReason(const SheetOptimizationData& data);
  
  // Analysis helpers
  int CountUsedColors(const std::vector<uint8_t>& data, const SnesPalette& palette);
  float CalculateColorEfficiency(const std::vector<uint8_t>& data, const SnesPalette& palette);
  std::vector<int> AnalyzeColorDistribution(const std::vector<uint8_t>& data);
  
  // Cache management
  std::string GenerateCacheKey(const std::vector<uint8_t>& data, int sheet_id);
  void UpdateOptimizationStats(const std::string& operation, double value);
};
 
class GraphicsOptimizationScope {
 public:
  GraphicsOptimizationScope(OptimizationStrategy strategy, int sheet_count);
  ~GraphicsOptimizationScope();
  
  void AddSheet(int sheet_id, size_t original_size, size_t optimized_size);
  void SetResult(const OptimizationResult& result);
  
 private:
  OptimizationStrategy strategy_;
  int sheet_count_;
  std::string operation_name_;
  ScopedTimer timer_;
  OptimizationResult result_;
};
 
}  // namespace gfx
}  // namespace yaze
 
#endif  // YAZE_APP_GFX_GRAPHICS_OPTIMIZER_H