Ticket #7130: scale2x icon scaling 3.diff

src/libs/icon/IconUtils.cpp

@@ -100 +100 @@
 }
 
 
+static void
+scale2x(const uint8* srcBits, uint8* dstBits, int32 srcWidth, int32 srcHeight,
+    int32 srcBPR, int32 dstBPR)
+{
+    /*
+     * This implements the AdvanceMAME Scale2x algorithm found on:
+     * http://scale2x.sourceforge.net/
+     * 
+     * It is an incredibly simple and powerful image doubling routine that does
+     * an astonishing job of doubling game graphic data while interpolating out
+     * the jaggies.
+     *
+     * Derived from the (public domain) SDL version of the library by Pete
+     * Shinners
+     */
+
+    // Assume that both src and dst are 4 BPP (B_RGBA32)
+    for(int32 looph = 0; looph < srcHeight; ++looph) {
+        for(int32 loopw = 0; loopw < srcWidth; ++loopw) {
+            uint32 b = *(uint32*)(srcBits + (MAX(0, looph - 1) * srcBPR)
+                + (4 * loopw));
+            uint32 d = *(uint32*)(srcBits + (looph * srcBPR)
+                + (4 * MAX(0, loopw - 1)));
+            uint32 e = *(uint32*)(srcBits + (looph * srcBPR)
+                + (4 * loopw));
+            uint32 f = *(uint32*)(srcBits + (looph * srcBPR)
+                + (4 * MIN(srcWidth - 1,loopw + 1)));
+            uint32 h = 
+                *(uint32*)(srcBits + (MIN(srcHeight - 1, looph + 1)
+                * srcBPR) + (4 * loopw));
+
+            uint32 e0 = d == b && b != f && d != h ? d : e;
+            uint32 e1 = b == f && b != d && f != h ? f : e;
+            uint32 e2 = d == h && d != b && h != f ? d : e;
+            uint32 e3 = h == f && d != h && b != f ? f : e;
+
+            *(uint32*)(dstBits + looph * 2 * dstBPR
+                + loopw * 2 * 4) = e0;
+            *(uint32*)(dstBits + looph * 2 * dstBPR
+                + (loopw * 2 + 1) * 4) = e1;
+            *(uint32*)(dstBits + (looph * 2 + 1) * dstBPR
+                + loopw * 2 * 4) = e2;
+            *(uint32*)(dstBits + (looph * 2 + 1) * dstBPR
+                + (loopw * 2 + 1) * 4) = e3;
+        }
+    }
+}
+
+
 //  #pragma mark -
 
 
@@ -464 +513 @@
 
     const rgb_color* colorMap = system_colors()->color_list;
 
+    const uint8* srcStart = src;
+    uint8* dstStart = dst;
+
     for (uint32 y = 0; y < height; y++) {
         uint32* d = (uint32*)dst;
         const uint8* s = src;
@@ -480 +532 @@
         dst += dstBPR;
     }
 
+    // reset src and dst back to their original locations
+    src = srcStart;
+    dst = dstStart;
+
     if (dstWidth > width || dstHeight > height) {
-        // up scaling
-        scale_bilinear((uint8*)result->Bits(), width, height, dstWidth,
-            dstHeight, dstBPR);
+        if (dstWidth == 2 * width && dstHeight == 2 * height) {
+            // scale using the scale2x algorithm
+            BBitmap* converted = new BBitmap(BRect(0, 0, width - 1, height - 1),
+                result->ColorSpace());
+            converted->ImportBits(src, height * srcBPR, srcBPR, 0, B_CMAP8);
+            uint8* convertedBits = (uint8*)converted->Bits();
+            int32 convertedBPR = converted->BytesPerRow();
+            scale2x(convertedBits, dst, width, height, convertedBPR, dstBPR);
+        } else {
+            // bilinear scaling
+            scale_bilinear(dst, width, height, dstWidth, dstHeight, dstBPR);
+        }
     }
 
     return B_OK;