added scaling

Author: mkalkbrenner

CMakeLists.txt

@@ -44,6 +44,7 @@ set(CMAKE_C_VISIBILITY_PRESET hidden)
 add_executable(ppuc-pinmame
    src/ppuc.cpp
    src/VirtualDMD.cpp
+   src/xbrz/xbrz.cpp
 )
 
 target_include_directories(ppuc-pinmame PUBLIC
@@ -94,6 +95,7 @@ endif()
 add_executable(ppuc-backbox
    src/backbox.cpp
    src/VirtualDMD.cpp
+   src/xbrz/xbrz.cpp
 )
 
 target_include_directories(ppuc-backbox PUBLIC

src/VirtualDMD.cpp

@@ -1,6 +1,28 @@
 #include "VirtualDMD.h"
 
+#include <vector>
+
+#include "xbrz/xbrz.h"
+
 void VirtualDMD::Update(uint8_t* pData)
+{
+  switch (m_renderingMode)
+  {
+    case RenderingMode::SmoothScaling:
+      RenderSmoothScaling(pData);
+      break;
+
+    case RenderingMode::XBRZ:
+      RenderXBRZ(pData);
+      break;
+
+    default:
+      RenderDots(pData);
+      break;
+  }
+}
+
+void VirtualDMD::RenderDots(uint8_t* pData)
 {
   // Get window size to calculate scaling
   int windowWidth, windowHeight;
@@ -56,3 +78,95 @@ void VirtualDMD::Update(uint8_t* pData)
 
   SDL_RenderPresent(m_pRenderer);
 }
+
+void VirtualDMD::RenderSmoothScaling(uint8_t* pData)
+{
+  int windowWidth, windowHeight;
+  SDL_GetRenderOutputSize(m_pRenderer, &windowWidth, &windowHeight);
+
+  // Create source texture
+  SDL_Texture* srcTexture =
+      SDL_CreateTexture(m_pRenderer, SDL_PIXELFORMAT_RGB24, SDL_TEXTUREACCESS_STATIC, m_width, m_height);
+  SDL_UpdateTexture(srcTexture, NULL, pData, m_width * 3);
+
+  // Create intermediate texture at 4x resolution
+  int intermediateW = m_width * 4;
+  int intermediateH = m_height * 4;
+  SDL_Texture* intermediate =
+      SDL_CreateTexture(m_pRenderer, SDL_PIXELFORMAT_RGB24, SDL_TEXTUREACCESS_TARGET, intermediateW, intermediateH);
+
+  // First scale pass (nearest neighbor to 4x)
+  SDL_SetRenderTarget(m_pRenderer, intermediate);
+  SDL_SetTextureScaleMode(srcTexture, SDL_SCALEMODE_NEAREST);
+  SDL_RenderTexture(m_pRenderer, srcTexture, NULL, NULL);
+
+  // Second scale pass (linear to final size)
+  SDL_SetRenderTarget(m_pRenderer, NULL);
+  SDL_SetTextureScaleMode(intermediate, SDL_SCALEMODE_LINEAR);
+  SDL_FRect dest = {0, 0, (float)windowWidth, (float)windowHeight};
+  SDL_RenderTexture(m_pRenderer, intermediate, NULL, &dest);
+
+  SDL_RenderPresent(m_pRenderer);
+
+  // Cleanup
+  SDL_DestroyTexture(srcTexture);
+  SDL_DestroyTexture(intermediate);
+}
+
+void VirtualDMD::RenderXBRZ(uint8_t* pData)
+{
+  // Get the window size
+  int windowWidth, windowHeight;
+  SDL_GetRenderOutputSize(m_pRenderer, &windowWidth, &windowHeight);
+
+  // Prepare source ARGB buffer
+  const int srcWidth = m_width;
+  const int srcHeight = m_height;
+  std::vector<uint32_t> srcImage(srcWidth * srcHeight);
+
+  for (int y = 0; y < srcHeight; ++y)
+  {
+    for (int x = 0; x < srcWidth; ++x)
+    {
+      int i = y * srcWidth + x;
+      int j = i * 3;
+      uint8_t r = pData[j];
+      uint8_t g = pData[j + 1];
+      uint8_t b = pData[j + 2];
+      srcImage[i] = (255u << 24) | (r << 16) | (g << 8) | b;  // ARGB format
+    }
+  }
+
+  // Set up xBRZ scaler configuration
+  xbrz::ScalerCfg cfg;
+  cfg.luminanceWeight = 1.0;
+  cfg.equalColorTolerance = 30.0;
+  cfg.centerDirectionBias = 4.0;
+  cfg.dominantDirectionThreshold = 3.6;
+  cfg.steepDirectionThreshold = 2.2;
+
+  // xBRZ upscale (max factor: 6)
+  const size_t scaleFactor = 6;
+  const int scaledWidth = srcWidth * scaleFactor;
+  const int scaledHeight = srcHeight * scaleFactor;
+  std::vector<uint32_t> dstImage(scaledWidth * scaledHeight);
+
+  xbrz::scale(scaleFactor, srcImage.data(), dstImage.data(), srcWidth, srcHeight, xbrz::ColorFormat::ARGB, cfg, 0,
+              srcHeight);
+
+  // Create an SDL texture from the scaled buffer
+  SDL_Texture* texture =
+      SDL_CreateTexture(m_pRenderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STATIC, scaledWidth, scaledHeight);
+
+  SDL_UpdateTexture(texture, nullptr, dstImage.data(), scaledWidth * sizeof(uint32_t));
+
+  // Clear and render the texture
+  SDL_RenderClear(m_pRenderer);
+
+  SDL_FRect dstRect = {0.0f, 0.0f, (float)windowWidth, (float)windowHeight};
+  SDL_RenderTexture(m_pRenderer, texture, nullptr, &dstRect);
+
+  SDL_RenderPresent(m_pRenderer);
+
+  SDL_DestroyTexture(texture);
+}

src/VirtualDMD.h

@@ -13,8 +13,22 @@ class DMDUTILAPI VirtualDMD : public DMDUtil::RGB24DMD
 
   ~VirtualDMD() { m_pRenderer = nullptr; }
 
+  enum RenderingMode : int
+  {
+    Dots = 0,
+    SmoothScaling = 1,
+    XBRZ = 2,
+  };
+
   virtual void Update(uint8_t* pData) override;
 
+  void SetRenderingMode(RenderingMode mode) { m_renderingMode = mode; }
+
  private:
   SDL_Renderer* m_pRenderer;
+  int m_renderingMode = RenderingMode::Dots;
+
+  void RenderDots(uint8_t* pData);
+  void RenderSmoothScaling(uint8_t* pData);
+  void RenderXBRZ(uint8_t* pData);
 };

src/backbox.cpp

@@ -107,6 +107,10 @@ static struct cag_option options[] = {
      .access_name = "virtual-dmd-screen",
      .value_name = "VALUE",
      .description = "Show virtual DMD on a specific screen"},
+    {.identifier = 'S',
+     .access_name = "virtual-dmd-scale",
+     .value_name = NULL,
+     .description = "Scale virtual DMD instead or rendering dots."},
     {.identifier = 'h', .access_letters = "h", .access_name = "help", .description = "Show help"}};
 
 void DMDUTILCALLBACK LogCallback(DMDUtil_LogLevel logLevel, const char* format, va_list args)
@@ -257,6 +261,7 @@ int main(int argc, char** argv)
   bool opt_virtual_dmd = false;
   bool opt_virtual_dmd_hd = false;
   bool opt_virtual_dmd_window = false;
+  bool opt_virtual_dmd_scale = false;
   uint16_t opt_virtual_dmd_width = 1280;
   uint16_t opt_virtual_dmd_height = 320;
   int8_t opt_virtual_dmd_screen = -1;
@@ -318,6 +323,9 @@ int main(int argc, char** argv)
       case 'R':
         opt_virtual_dmd_screen = atoi(cag_option_get_value(&cag_context));
         break;
+      case 'S':
+        opt_virtual_dmd_scale = true;
+        break;
       case 'h':
         printf("Usage: ppuc [OPTION]...\n");
         cag_option_print(options, CAG_ARRAY_SIZE(options), stdout);
@@ -445,6 +453,11 @@ int main(int argc, char** argv)
       pVirtualDMD = new VirtualDMD(pVirtualDMDRenderer, 128, 32);
     }
 
+    if (opt_virtual_dmd_scale)
+    {
+      pVirtualDMD->SetRenderingMode(VirtualDMD::RenderingMode::XBRZ);
+    }
+
     pDmd->AddRGB24DMD((DMDUtil::RGB24DMD* const)pVirtualDMD);
   }
 

src/xbrz/Changelog.txt

@@ -0,0 +1,66 @@
+xBRZ 1.8 [2019-11-28]
+---------------------
+Consider ARGB outside area as transparent
+Fixed ARGB scaling issue on image borders
+
+
+xBRZ 1.7 [2019-07-04]
+---------------------
+Fixed asymmetric color distance
+New parameter: "Center direction bias"
+
+
+xBRZ 1.6 [2018-02-27]
+---------------------
+Added bilinear scaling
+Option to skip color buffer creation
+Updated license info
+
+
+xBRZ 1.5 [2017-08-07]
+---------------------
+Added RGB conversion routines
+
+
+xBRZ 1.4 [2015-07-25]
+---------------------
+Added 6xBRZ scaler
+Create color distance buffer lazily
+
+
+xBRZ 1.3 [2015-04-03]
+---------------------
+Improved ARGB performance by 15%
+Fixed alpha channel gradient bug
+
+
+xBRZ 1.2 [2014-11-21]
+---------------------
+Further improved performance by over 30%
+
+
+xBRZ 1.1 [2014-11-02]
+---------------------
+Support images with alpha channel
+Improved color analysis
+
+
+xBRZ 1.0 [2013-02-11]
+---------------------
+Fixed xBRZ scaler compiler issues for GCC
+
+ 
+xBRZ 0.2 [2012-12-11]
+---------------------
+Added 5xBRZ scaler
+Optimized xBRZ scaler performance by factor 3
+Further improved image quality of xBRZ scaler
+
+
+xBRZ 0.1 [2012-09-26]
+---------------------
+Initial release:
+- scale while preserving small image features
+- support multithreading
+- support 64-bit architectures
+- support processing image slices