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 "app/platform/sdl_compat.h"
 
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "app/gfx/core/bitmap.h"
#include "app/gfx/debug/performance/performance_profiler.h"
#include "app/gfx/types/snes_palette.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