Ticket #7130: scale2x icon scaling.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
+     */
+
+    int looph, loopw;
+
+    switch(bpp) {
+        case 1:
+        {
+            uint8 E0, E1, E2, E3, B, D, E, F, H;
+
+            for(looph = 0; looph < srcHeight; ++looph) {
+                for(loopw = 0; loopw < srcWidth; ++ loopw) {
+                    B = *(uint8*)(srcBits + (MAX(0, looph - 1) * srcBPR)
+                        + (1 * loopw));
+                    D = *(uint8*)(srcBits + (looph * srcBPR)
+                        + (1 * MAX(0, loopw - 1)));
+                    E = *(uint8*)(srcBits + (looph * srcBPR) + (1 * loopw));
+                    F = *(uint8*)(srcBits + (looph * srcBPR)
+                        + (1 * MIN(srcWidth - 1, loopw+1)));
+                    H = *(uint8*)(srcBits + (MIN(srcHeight - 1, looph + 1)
+                        * srcBPR) + (1 * loopw));
+
+                    E0 = D == B && B != F && D != H ? D : E;
+                    E1 = B == F && B != D && F != H ? F : E;
+                    E2 = D == H && D != B && H != F ? D : E;
+                    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:
+        {
+            uint32 E0, E1, E2, E3, B, D, E, F, H;
+
+            for(looph = 0; looph < srcHeight; ++looph) {
+                for(loopw = 0; loopw < srcWidth; ++ loopw) {
+                    B = *(uint32*)(srcBits + (MAX(0, looph - 1) * srcBPR)
+                        + (4 * loopw));
+                    D = *(uint32*)(srcBits + (looph * srcBPR)
+                        + (4 * MAX(0, loopw - 1)));
+                    E = *(uint32*)(srcBits + (looph * srcBPR) + (4 * loopw));
+                    F = *(uint32*)(srcBits + (looph * srcBPR)
+                        + (4 * MIN(srcWidth - 1,loopw + 1)));
+                    H = *(uint32*)(srcBits + (MIN(srcHeight - 1, looph + 1)
+                        * srcBPR) + (4 * loopw));
+
+                    E0 = D == B && B != F && D != H ? D : E;
+                    E1 = B == F && B != D && F != H ? F : E;
+                    E2 = D == H && D != B && H != F ? D : E;
+                    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 +553 @@
 
     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 +572 @@
         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;