bpp_format_manager.h

Go to the documentation of this file.

#ifndef YAZE_APP_GFX_BPP_FORMAT_MANAGER_H
#define YAZE_APP_GFX_BPP_FORMAT_MANAGER_H
 
#include <SDL.h>
#include <vector>
#include <unordered_map>
#include <memory>
#include <string>
 
#include "app/gfx/bitmap.h"
#include "app/gfx/snes_palette.h"
#include "app/gfx/performance/performance_profiler.h"
 
namespace yaze {
namespace gfx {
 
enum class BppFormat {
  kBpp2 = 2,    
  kBpp3 = 3,    
  kBpp4 = 4,    
  kBpp8 = 8     
};
 
struct BppFormatInfo {
  BppFormat format;
  std::string name;
  int bits_per_pixel;
  int max_colors;
  int bytes_per_tile;
  int bytes_per_sheet;
  bool is_compressed;
  std::string description;
  
  BppFormatInfo() = default;
  
  BppFormatInfo(BppFormat fmt, const std::string& n, int bpp, int max_col, 
                int bytes_tile, int bytes_sheet, bool compressed, const std::string& desc)
    : format(fmt), name(n), bits_per_pixel(bpp), max_colors(max_col),
      bytes_per_tile(bytes_tile), bytes_per_sheet(bytes_sheet), 
      is_compressed(compressed), description(desc) {}
};
 
struct GraphicsSheetAnalysis {
  int sheet_id;
  BppFormat original_format;
  BppFormat current_format;
  bool was_converted;
  std::string conversion_history;
  int palette_entries_used;
  float compression_ratio;
  size_t original_size;
  size_t current_size;
  std::vector<int> tile_usage_pattern;
  
  GraphicsSheetAnalysis() : sheet_id(-1), original_format(BppFormat::kBpp8),
                           current_format(BppFormat::kBpp8), was_converted(false),
                           palette_entries_used(0), compression_ratio(1.0f),
                           original_size(0), current_size(0) {}
};
 
class BppFormatManager {
 public:
  static BppFormatManager& Get();
  
  void Initialize();
  
  const BppFormatInfo& GetFormatInfo(BppFormat format) const;
  
  std::vector<BppFormat> GetAvailableFormats() const;
  
  std::vector<uint8_t> ConvertFormat(const std::vector<uint8_t>& data,
                                    BppFormat from_format, BppFormat to_format,
                                    int width, int height);
  
  GraphicsSheetAnalysis AnalyzeGraphicsSheet(const std::vector<uint8_t>& sheet_data,
                                            int sheet_id,
                                            const SnesPalette& palette);
  
  BppFormat DetectFormat(const std::vector<uint8_t>& data, int width, int height);
  
  SnesPalette OptimizePaletteForFormat(const SnesPalette& palette,
                                      BppFormat target_format,
                                      const std::vector<int>& used_colors);
  
  std::unordered_map<std::string, int> GetConversionStats() const;
  
  void ClearCache();
  
  std::pair<size_t, size_t> GetMemoryStats() const;
 
 private:
  BppFormatManager() = default;
  ~BppFormatManager() = default;
  
  // Format information storage
  std::unordered_map<BppFormat, BppFormatInfo> format_info_;
  
  // Conversion cache for performance
  std::unordered_map<std::string, std::vector<uint8_t>> conversion_cache_;
  
  // Analysis cache
  std::unordered_map<int, GraphicsSheetAnalysis> analysis_cache_;
  
  // Statistics tracking
  std::unordered_map<std::string, int> conversion_stats_;
  
  // Memory usage tracking
  size_t cache_memory_usage_;
  size_t max_cache_size_;
  
  // Helper methods
  void InitializeFormatInfo();
  std::string GenerateCacheKey(const std::vector<uint8_t>& data, 
                              BppFormat from_format, BppFormat to_format,
                              int width, int height);
  BppFormat AnalyzeColorDepth(const std::vector<uint8_t>& data, int width, int height);
  std::vector<uint8_t> Convert2BppTo8Bpp(const std::vector<uint8_t>& data, int width, int height);
  std::vector<uint8_t> Convert3BppTo8Bpp(const std::vector<uint8_t>& data, int width, int height);
  std::vector<uint8_t> Convert4BppTo8Bpp(const std::vector<uint8_t>& data, int width, int height);
  std::vector<uint8_t> Convert8BppTo2Bpp(const std::vector<uint8_t>& data, int width, int height);
  std::vector<uint8_t> Convert8BppTo3Bpp(const std::vector<uint8_t>& data, int width, int height);
  std::vector<uint8_t> Convert8BppTo4Bpp(const std::vector<uint8_t>& data, int width, int height);
  
  // Analysis helpers
  int CountUsedColors(const std::vector<uint8_t>& data, int max_colors);
  float CalculateCompressionRatio(const std::vector<uint8_t>& original, 
                                 const std::vector<uint8_t>& compressed);
  std::vector<int> AnalyzeTileUsagePattern(const std::vector<uint8_t>& data, 
                                          int width, int height, int tile_size);
};
 
class BppConversionScope {
 public:
  BppConversionScope(BppFormat from_format, BppFormat to_format, int width, int height);
  ~BppConversionScope();
  
  std::vector<uint8_t> Convert(const std::vector<uint8_t>& data);
  
 private:
  BppFormat from_format_;
  BppFormat to_format_;
  int width_;
  int height_;
  std::string operation_name_;
  ScopedTimer timer_;
};
 
}  // namespace gfx
}  // namespace yaze
 
#endif  // YAZE_APP_GFX_BPP_FORMAT_MANAGER_H