Make image decoders faster by refactoring hot loops that fills the lines of ImageFrame.

Source/core/platform/graphics/Color.cpp

Index: Source/core/platform/graphics/Color.cpp
diff --git a/Source/core/platform/graphics/Color.cpp b/Source/core/platform/graphics/Color.cpp
index c6bdeb25cdf5afa5f9bd920d10fa0de997b963a3..1f65ac7f30572707a0330170328e9a6445737183 100644
--- a/Source/core/platform/graphics/Color.cpp
+++ b/Source/core/platform/graphics/Color.cpp
@@ -27,11 +27,11 @@
 #include "core/platform/graphics/Color.h"
 
 #include "core/platform/HashTools.h"
-#include <wtf/Assertions.h>
-#include <wtf/DecimalNumber.h>
-#include <wtf/HexNumber.h>
-#include <wtf/MathExtras.h>
-#include <wtf/text/StringBuilder.h>
+#include "wtf/Assertions.h"
+#include "wtf/DecimalNumber.h"
+#include "wtf/HexNumber.h"
+#include "wtf/MathExtras.h"
+#include "wtf/text/StringBuilder.h"
 
 using namespace std;
 
@@ -434,9 +434,9 @@ RGBA32 premultipliedARGBFromColor(const Color& color)
     unsigned alpha = color.alpha();
     if (alpha < 255) {
         pixelColor = Color::createUnchecked(
-            (color.red() * alpha  + 254) / 255,
-            (color.green() * alpha  + 254) / 255,
-            (color.blue() * alpha  + 254) / 255,
+            WTF::fastDivideBy255(color.red() * alpha + 254),
+            WTF::fastDivideBy255(color.green() * alpha + 254),
+            WTF::fastDivideBy255(color.blue() * alpha + 254),

[Noel Gordon, 2013/05/25 04:40:56]

The Color.cpp change should really be a separate patch, with caveats:

So we want (color * alpha + 254) / 255 and propose to use fastDivideBy255, which
is 24 ops per RGB pixel.  However, (color * alpha + 254) / 255 is the same as
SkMulDiv255Ceiling

  https://bugs.webkit.org/attachment.cgi?id=76488&action=prettypatch
  https://codereview.appspot.com/3466042

which is 15 ops per RGB pixel.  Next, there's the faster ceiling implementation
from crbug.com/234071 which gets it down to 10 ops per RGB pixel.  Here's a test
program you can use to test the bit exactness of the various methods.

#include <stdio.h>

int main(int argc, char** argv)
{
  for (int color = 0; color < 256; ++color) {
    for (int alpha = 0; alpha < 256; ++alpha) {
      // Webkit int math: integer divide.
      int webkit = (color * alpha + 254) / 255;

      // SkMulDiv255Ceiling: no divide, 15 ops per RGB pixel.
      int skia_ceiling = (color * alpha + 255);
      int skia = (skia_ceiling + (skia_ceiling >> 8)) >> 8;
      if (skia != webkit)
        printf("skia diff on color %d alpha %d: skia %d, webkit %d\n",
            color, alpha, skia, webkit);

      // FastDiv255Ceiling: no divide, 10 ops per RGB pixel.
      const int ceilingFraction = 257 * 255;
      int fast_ceiling = alpha * 257;
      int fast = (color * fast_ceiling + ceilingFraction) >> 16;
      if (fast != webkit)
        printf("factored diff on color %d alpha %d: skia %d, webkit %d fast
%d\n",
            color, alpha, skia, webkit, fast);
    }
  }

  return 0;
}

So if RGBA32 premultipliedARGBFromColor(const Color& color) needs to be fast
(well, does it?) you could implement the calculation here as

    unsigned a = a * 257;
    r = (r * a + ceilingFraction) >> 16;
    g = (g * a + ceilingFraction) >> 16;
    b = (b * a + ceilingFraction) >> 16;

where ceilingFraction is a constant 257 * 255.

Again, I think it would be better to deal with the Color changes on a separate
patch.

             alpha).rgb();
     } else
          pixelColor = color.rgb();