Implement InterpolationMedium to filter animated images

Source/platform/graphics/skia/NativeImageSkia.cpp

 /*
  * Copyright (c) 2008, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 126 matching lines @@
 
     return LinearResampling;
 }
 
 static ResamplingMode limitResamplingMode(GraphicsContext* context, ResamplingMode resampling)
 {
     switch (context->imageInterpolationQuality()) {
     case InterpolationNone:
         return NoResampling;
     case InterpolationMedium:
-        // For now we treat InterpolationMedium and InterpolationLow the same.
+        if (resampling == AwesomeResampling)
+            return MediumResampling;
+        break;
     case InterpolationLow:
-        if (resampling == AwesomeResampling)
+        if (resampling == AwesomeResampling || resampling == MediumResampling)
             return LinearResampling;
         break;
     case InterpolationHigh:
-    case InterpolationDefault:

[Stephen Chennney, 2014/03/18 12:56:32]

I think you'll get build errors due to enum not in the switch.

[Alpha Left Google, 2014/03/18 22:59:13]

Actually this is correct since InterpolationDefault equals InterpolationLow or
InterpolationHigh. The code now is actually cleaner.

         break;
     }
 
     return resampling;
 }
 
 // This function is used to scale an image and extract a scaled fragment.
 //
 // ALGORITHM
 //
@@ skipping 182 matching lines @@
             SkScalarToFloat(destRectTarget.width()), SkScalarToFloat(destRectTarget.height()));
     }
 
     if (resampling == NoResampling) {
         // FIXME: This is to not break tests (it results in the filter bitmap flag
         // being set to true). We need to decide if we respect NoResampling
         // being returned from computeResamplingMode.
         resampling = LinearResampling;
     }
     resampling = limitResamplingMode(context, resampling);
-    paint.setFilterBitmap(resampling == LinearResampling);
 
     bool isLazyDecoded = DeferredImageDecoder::isLazyDecoded(bitmap());
     // FIXME: Bicubic filtering in Skia is only applied to defer-decoded images
     // as an experiment. Once this filtering code path becomes stable we should
     // turn this on for all cases, including non-defer-decoded images.
     bool useBicubicFilter = resampling == AwesomeResampling && isLazyDecoded;
 
     if (useBicubicFilter)
         paint.setFilterLevel(SkPaint::kHigh_FilterLevel);
+    else if (resampling == MediumResampling)

[Stephen White, 2014/03/18 17:26:43]

I'd suggest to refactor this out into a helper function that converts between
resampling mode + useBicubicFilter and filterlevel, and call that here and
below.

[Alpha Left Google, 2014/03/18 22:59:13]

Done.

+        paint.setFilterLevel(SkPaint::kMedium_FilterLevel);
+    else if (resampling == LinearResampling)
+        paint.setFilterLevel(SkPaint::kLow_FilterLevel);
+    else
+        paint.setFilterLevel(SkPaint::kNone_FilterLevel);
 
     if (resampling == AwesomeResampling && !useBicubicFilter) {
         // Resample the image and then draw the result to canvas with bilinear
         // filtering.
         drawResampledBitmap(context, paint, srcRect, destRect);
     } else {
         // We want to filter it if we decided to do interpolation above, or if
         // there is something interesting going on with the matrix (like a rotation).
         // Note: for serialization, we will want to subset the bitmap first so we
         // don't send extra pixels.
@@ skipping 114 matching lines @@
     float adjustedX = phase.x() + normSrcRect.x() * scale.width();
     float adjustedY = phase.y() + normSrcRect.y() * scale.height();
     shaderTransform.postTranslate(SkFloatToScalar(adjustedX), SkFloatToScalar(adjustedY));
     shader->setLocalMatrix(shaderTransform);
 
     SkPaint paint;
     paint.setShader(shader.get());
     paint.setXfermode(WebCoreCompositeToSkiaComposite(compositeOp, blendMode).get());
     paint.setColorFilter(context->colorFilter());
 
-    paint.setFilterBitmap(resampling == LinearResampling);
     if (useBicubicFilter)
         paint.setFilterLevel(SkPaint::kHigh_FilterLevel);
+    else if (resampling == MediumResampling)
+        paint.setFilterLevel(SkPaint::kMedium_FilterLevel);
+    else if (resampling == LinearResampling)
+        paint.setFilterLevel(SkPaint::kLow_FilterLevel);
+    else
+        paint.setFilterLevel(SkPaint::kNone_FilterLevel);
     if (isLazyDecoded)
         PlatformInstrumentation::didDrawLazyPixelRef(bitmap().getGenerationID());
 
     context->drawRect(destRect, paint);
 }
 
 bool NativeImageSkia::shouldCacheResampling(const SkISize& scaledImageSize, const SkIRect& scaledImageSubset) const
 {
     // Check whether the requested dimensions match previous request.
     bool matchesPreviousRequest = m_cachedImageInfo.isEqual(scaledImageSize, scaledImageSubset);
@@ skipping 59 matching lines @@
 SkIRect NativeImageSkia::ImageResourceInfo::rectInSubset(const SkIRect& otherScaledImageSubset)
 {
     if (!scaledImageSubset.contains(otherScaledImageSubset))
         return SkIRect::MakeEmpty();
     SkIRect subsetRect = otherScaledImageSubset;
     subsetRect.offset(-scaledImageSubset.x(), -scaledImageSubset.y());
     return subsetRect;
 }
 
 } // namespace WebCore