Ticket #7130: scale2x icon scaling 2.diff

src/libs/icon/IconUtils.cpp

@@ -100 +100 @@
 }
 
 
+static void
+scale2x(const uint8* srcBits, uint8* dstBits, int32 srcWidth, int32 srcHeight,
+    int32 srcBPR, int32 dstBPR, int32 bpp)
+{
+    /*
+     * 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
+     */
+
+    switch(bpp) {
+        case 1:
+        {
+            for(int32 looph = 0; looph < srcHeight; ++looph) {
+                for(int32 loopw = 0; loopw < srcWidth; ++ loopw) {
+                    uint8 b = *(uint8*)(srcBits + (MAX(0, looph - 1) * srcBPR)
+                        + (1 * loopw));
+                    uint8 d = *(uint8*)(srcBits + (looph * srcBPR)
+                        + (1 * MAX(0, loopw - 1)));
+                    uint8 e = *(uint8*)(srcBits + (looph * srcBPR)
+                        + (1 * loopw));
+                    uint8 f = *(uint8*)(srcBits + (looph * srcBPR)
+                        + (1 * MIN(srcWidth - 1, loopw+1)));
+                    uint8 h = *(uint8*)(srcBits + (MIN(srcHeight - 1, looph + 1)
+                        * srcBPR) + (1 * loopw));
+
+                    uint8 e0 = d == b && b != f && d != h ? d : e;
+                    uint8 e1 = b == f && b != d && f != h ? f : e;
+                    uint8 e2 = d == h && d != b && h != f ? d : e;
+                    uint8 e3 = h == f && d != h && b != f ? f : e;
+
+                    *(uint8*)(dstBits + looph * 2 * dstBPR
+                        + loopw * 2 * 1) = e0;
+                    *(uint8*)(dstBits + looph * 2 * dstBPR
+                        + (loopw * 2 + 1) * 1) = e1;
+                    *(uint8*)(dstBits + (looph * 2 + 1) * dstBPR
+                        + loopw * 2 * 1) = e2;
+                    *(uint8*)(dstBits + (looph * 2 + 1) * dstBPR
+                        + (loopw * 2 + 1) * 1) = e3;
+                }
+            }
+            break;
+        }
+        case 4:
+        {
+            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;
+                }
+            }
+            break;
+        }
+    }
+}
+
+
 //  #pragma mark -
 
 
@@ -464 +550 @@
 
     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 +569 @@
         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, 4);
+        } else {
+            // bilinear scaling
+            scale_bilinear(dst, width, height, dstWidth, dstHeight, dstBPR);
+        }
     }
 
     return B_OK;