Bilerp + mirror + perspective

src/core/SkBitmapProcState.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapCache.h"
 #include "SkBitmapController.h"
 #include "SkBitmapProcState.h"
@@ skipping 119 matching lines @@
     }
 
     SkDefaultBitmapController controller;
     fBMState = controller.requestBitmap(fProvider, inv, paint.getFilterQuality(),
                                         fBMStateStorage.get(), fBMStateStorage.size());
     // Note : we allow the controller to return an empty (zero-dimension) result. Should we?
     if (nullptr == fBMState || fBMState->pixmap().info().isEmpty()) {
         return false;
     }
     fPixmap = fBMState->pixmap();
+    //SkASSERT(fPixmap.colorType() == fProvider.info().colorType());

[reed1, 2016/03/22 19:17:45]

can we restore this assert? do we want to?

[herb_g, 2016/03/22 20:26:57]

I should remove this assert. I think we proved to ourselves that in general this
could not be true.

     fInvMatrix = fBMState->invMatrix();
+    fRealInvMatrix = fBMState->invMatrix();
     fPaintColor = paint.getColor();
     fFilterQuality = fBMState->quality();
     SkASSERT(fPixmap.addr());
 
     bool trivialMatrix = (fInvMatrix.getType() & ~SkMatrix::kTranslate_Mask) == 0;
     bool clampClamp = SkShader::kClamp_TileMode == fTileModeX &&
                       SkShader::kClamp_TileMode == fTileModeY;
 
     // Most of the scanline procs deal with "unit" texture coordinates, as this
     // makes it easy to perform tiling modes (repeat = (x & 0xFFFF)). To generate
@@ skipping 40 matching lines @@
     if (kLow_SkFilterQuality == fFilterQuality && allow_ignore_fractional_translate) {
         // Only try bilerp if the matrix is "interesting" and
         // the image has a suitable size.
 
         if (fInvType <= SkMatrix::kTranslate_Mask ||
             !valid_for_filtering(fPixmap.width() | fPixmap.height()))
         {
             fFilterQuality = kNone_SkFilterQuality;
         }
     }
-    
+
     return true;
 }
 
 /*
  *  Analyze filter-quality and matrix, and decide how to implement that.
  *
  *  In general, we cascade down the request level [ High ... None ]
  *  - for a given level, if we can fulfill it, fine, else
  *    - else we downgrade to the next lower level and try again.
  *  We can always fulfill requests for Low and None
@@ skipping 113 matching lines @@
             SI8_alpha_D32_filter_DX,
 
             S4444_opaque_D32_nofilter_DXDY,
             S4444_alpha_D32_nofilter_DXDY,
             S4444_opaque_D32_nofilter_DX,
             S4444_alpha_D32_nofilter_DX,
             S4444_opaque_D32_filter_DXDY,
             S4444_alpha_D32_filter_DXDY,
             S4444_opaque_D32_filter_DX,
             S4444_alpha_D32_filter_DX,
-            
+
             // A8 treats alpha/opaque the same (equally efficient)
             SA8_alpha_D32_nofilter_DXDY,
             SA8_alpha_D32_nofilter_DXDY,
             SA8_alpha_D32_nofilter_DX,
             SA8_alpha_D32_nofilter_DX,
             SA8_alpha_D32_filter_DXDY,
             SA8_alpha_D32_filter_DXDY,
             SA8_alpha_D32_filter_DX,
             SA8_alpha_D32_filter_DX,
-            
+
             // todo: possibly specialize on opaqueness
             SG8_alpha_D32_nofilter_DXDY,
             SG8_alpha_D32_nofilter_DXDY,
             SG8_alpha_D32_nofilter_DX,
             SG8_alpha_D32_nofilter_DX,
             SG8_alpha_D32_filter_DXDY,
             SG8_alpha_D32_filter_DXDY,
             SG8_alpha_D32_filter_DX,
             SG8_alpha_D32_filter_DX
         };
@@ skipping 461 matching lines @@
             fx += dx;
         }
     } else {
         for (int i = 0; i < count; ++i) {
             dst[i] = src[SkClampMax(SkFractionalIntToInt(fx), maxX)];
             fx += dx;
         }
     }
 }