一、渲染層級
從渲染流程上分，Skia可分為如下三個層級：
1、指令層：SkPicture、SkDeferredCanvas->SkCanvas
這一層決定需要執行哪些繪圖操作，繪圖操作的預變換矩陣，當前裁剪區域，繪圖操作產生在哪些layer上，Layer的生成與合并。
2、解析層：SkBitmapDevice->SkDraw->SkScan、SkDraw1Glyph::Proc
這一層決定繪制方式，完成坐標變換，解析出需要繪制的形體（點/線/規整矩形）并做好抗鋸齒處理，進行相關資源解析并設置好Shader。
3、渲染層：SkBlitter->SkBlitRow::Proc、SkShader::shadeSpan等

這一層進行采樣（如果需要），產生實際的繪制效果，完成顏色格式適配，進行透明度混合和抖動處理（如果需要）。

二、主要類介紹
1、SkCanvas
這是復雜度超出想像的一個類。
（1）API設計
a、創建：
在Android中，主要的創建方法是由SkBitmap創建SkCanvas：
explicit SkCanvas(const SkBitmap& bitmap);
這個方法是由bitmap創建一個SkBitmapDevice，再將這個SkBitmapDevice設定為SkCanvas的渲染目標。


5.0之后提供了一個快捷方法創建SkCanvas：
static SkCanvas* NewRasterDirect(const SkImageInfo&, void*, size_t);
這樣Android的GraphicBuffer就不需要建一個SkBitmap和它關聯了，可以解除SkBitmap類和android runtime的關系（雖然如此，目前Android5.0上，還是按建SkBitmap的方法去關聯GraphicBuffer）。


5.0之后引入的離屏渲染：
static SkCanvas* NewRaster(const SkImageInfo&);
創建一個SkCanvas，繪制的內容需要通過readPixels去讀取，仍然是CPU繪圖的方式。（個人覺得這個是轉入GPU硬件加速的一個比較方便的接口，不知道出于什么考慮還是用CPU繪圖。）


b、狀態：
矩陣狀態：
矩陣決定當前繪制的幾何變換
rotate、skew、scale、translate、concat
裁剪狀態：
裁剪決定當前繪制的生效范圍
clipRect、clipRRect、clipPath、clipRegion
保存與恢復：
save、saveLayer、saveLayerAlpha、restore
c、渲染：
大部分渲染的API都可由這三個組合而成：
drawRect（矩形/圖像繪制）、drawPath（不規則圖形圖像繪制）和drawText（文本繪制）
d、像素的讀取與寫入
readPixels、writePixels
這兩個API主要由device實現，考慮到不同繪圖設備的異質性。


（2）MCRec狀態棧
fMCStack是存儲的全部狀態集，fMCRec則是當前的狀態。
在 save saveLayer saveLayerAlpha 時，會新建一個MCRec，在restore時，銷毀棧頂的MCRec。
（代碼見：SkCanvas.cpp internalSave函數，通過這段代碼可以了解一下new的各種用法～。）
每個狀態包括如下信息：
class SkCanvas::MCRec {
public:
? ? int ? ? ? ? ? ? fFlags;//保存的狀態標識（是否保存矩陣/裁剪/圖層）
? ? SkMatrix* ? ? ? fMatrix;//矩陣指針，若這個狀態有獨立矩陣，則指向內存（fMatrixStorage），否則用上一個MCRec的fMatrix
? ? SkRasterClip* ? fRasterClip;//裁剪區域，若這個狀態有獨立裁剪區域，則指向內存（fRasterClip），否則繼承上一個的。
? ? SkDrawFilter* ? fFilter;
? ? DeviceCM* fLayer;//這個狀態所擁有的layer（需要在此MCRec銷毀時回收）
? ? DeviceCM* fTopLayer;//這個狀態下，所需要繪制的Layer鏈表。（這些Layer不一定屬于此狀態）
? ? ......
};
DeviceCM：圖層鏈表，包裝一個SkBaseDevice，附加一個位置偏移變化的矩陣（在saveLayer時指定的坐標）。


（3）兩重循環繪制
研究Skia的人，一般來說都會被一開始的兩重循環弄暈一會，比如drawRect的代碼：


? ? LOOPER_BEGIN(paint, SkDrawFilter::kRect_Type, bounds)


? ? while (iter.next()) {
? ? ? ? iter.fDevice->drawRect(iter, r, looper.paint());
? ? }


? ? LOOPER_END


先完全展開上面的代碼：
AutoDrawLooper ?looper(this, paint, false, bounds);
while (looper.next(type)) {
? ? SkDrawIter ? ? ? ? ?iter(this);
? ? while (iter.next()) {
? ? ? ? iter.fDevice->drawRect(iter, r, looper.paint());
? ? }
}


第一重循環即 AutoDrawLooper，這個next實際上是做一個后處理，在存在 SkImageFilter 的情況下，先渲染到臨時Layer上，再將這個Layer做Filter處理后畫到當前device上。
第二重循環是SkDrawIter，這個是繪制當前狀態所依附的所有Layer。
一般情況下，這兩重循環都可以忽略，單純當它是走下流程就好了。


個人認為Skia在繪制入口SkCanvas的設計并不是很好，圖層、矩陣與裁剪存在一起，導致渲染任務難以剝離，后面GPU渲染和延遲渲染的引入都讓人感到有些生硬。


2、SkDraw、SkBlitter
這兩個類在后續章節還會提到，這里只簡單介紹：
SkDraw是CPU繪圖的實現入口，主要任務是做渲染準備（形狀確定、幾何變換、字體解析、構建圖像Shader等）。
SkBlitter 不是單獨的一個類，指代了一系列根據圖像格式、是否包含Shader等區分出來的一系列子類。
這一族類執行大塊頭的渲染任務，把像素繪制上去。




三、渲染框架設計思想分析
1、指令層與實現層分離
SkCanvas不直接執行渲染，由SkBaseDevice根據設備類型，選擇渲染方法。這樣雖然是同一套API，但可以用作GPU繪圖、pdf繪制、存儲顯示列表等各種功能。在API集上做優化，避免冗余繪制，也因此成為可能（注：這個google雖然在嘗試，但目前看來沒有明顯效果，實現起來確實也很困難）。
2、圖=形+色的設計思想
由SkDraw和SkScan類中控制繪制的形，由SkBlitter和SkShader控制繪制的色，將繪圖操作分解為形狀與色彩兩部分，這一點和OpenGL的頂點變換——光柵——片斷著色管線相似，非常有利于擴展，各種2D圖元的繪制基本上就完全支持了。
3、性能調優集中化
將耗時的函數抽象都抽象為proc，由一個工廠制造，便于集中對這一系列函數做優化。

此篇講Skia繪制圖片的流程，在下一篇講圖像采樣原理、混合和抖動技術
1、API用法
（1）drawBitmap
void drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top, const SkPaint* paint = NULL);
將bitmap畫到x,y的位置（這本身是一個平移，需要和SkCanvas中的矩陣狀態疊加）。
（2）drawBitmapRect 和 drawBitmapRectToRect
void drawBitmapRect(const SkBitmap& bitmap, const SkRect& dst, const SkPaint* paint = NULL);
void drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src, const SkRect& dst, const SkPaint* paint, DrawBitmapRectFlags flags);
將源圖src矩陣部分，畫到目標dst區域去。
最后一個flags是AndroidL上為了gpu繪制效果而加上去的，在CPU繪制中不需要關注。
（3）drawSprite
void drawSprite(const SkBitmap& bitmap, int x, int y, const SkPaint* paint);
無視SkCanvas的矩陣狀態，將bitmap平移到x,y的位置。
（4）drawBitmapMatrix
void drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& matrix, const SkPaint* paint);
繪制的bitmap帶有matrix的矩形變換，需要和SkCanvas的矩形變換疊加。
（5）drawRect
void drawRect(const SkRect& r, const SkPaint& paint);
這個是最通用的方法，多用于需要加入額外效果的場景，比如需要繪制重復紋理。關于Tile的兩個參數就是OpenGL紋理貼圖中水平垂直方向上的邊界處理模式。
由這種用法，大家不難類推到非矩形圖像繪制的方法，比如畫圓角矩形圖標、把方圖片裁剪成一個圓等。
下面是一個Demo程序

#include "SkBitmapProcShader.h"
#include "SkCanvas.h"
#include "SkBitmap.h"
#include "SkImageDecoder.h"
#include "SkImageEncoder.h"
#include "SkRect.h"
int main()
{
? ? const int w = 1080;
? ? const int h = 1920;
? ? /*準備目標圖片和源圖片*/
? ? SkBitmap dst;
? ? dst.allocPixels(SkImageInfo::Make(w, h, kN32_SkColorType, kPremul_SkAlphaType));
? ? SkCanvas c(dst);


? ? SkBitmap src;
? ? SkImageDecoder::DecodeFile("test.jpg", &src);


? ? /*各種繪制圖片方法使用示例*/
? ? {
? ? ? ? c.drawBitmap(src, 0, 0, NULL);
? ? }


? ? {
? ? ? ? c.drawSprite(src, 400, 400, NULL);
? ? }
? ? {
? ? ? ? SkRect dstR;
? ? ? ? r.set(29, 29, 100, 100);
? ? ? ? SkRect srcR;
? ? ? ? r.set(0,0,40,50);
? ? ? ? c.drawBitmapRectToRect(src, &srcR, dstR, NULL);
? ? }
? ? {
? ? ? ? SkMatrix m;
? ? ? ? m.setScale(1.4,4.3);
? ? ? ? c.drawBitmapMatrix(src, m, NULL);
? ? }
? ? {
? ? ? ? SkRect dstRect;
? ? ? ? dstRect.set(100,100,480,920);
? ? ? ? SkPaint paint;
? ? ? ? SkMatrix m;
? ? ? ? m.setScale(3.2, 4.1);
? ? ? ? SkShader* shader = CreateBitmapShader(src, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, m, NULL);
? ? ? ? paint.setShader(shader);
? ? ? ? SkSafeUnref(shader);
? ? ? ? c.drawRect(dstRect, paint);
? ? }


? ? /*輸出圖片*/
? ? SkImageEncoder::EncodeFile("output.jpg", dst, SkImageEncoder::kJPEG_Type, 100);
? ? return 1;
}

（1）SkCanvas兩重循環調到SkBitmapDevice，進而調到SkDraw
在SkDraw中，drawBitmap的渲染函數統一為：
void SkDraw::drawBitmap(const SkBitmap& bitmap, const SkMatrix& prematrix, const SkPaint& origPaint) const;
（2）Sprite簡易模式
在滿足如下條件時，走進Sprite簡易模式。
代碼見 external/skia/src/core/SkDraw.cpp drawBitmap 函數
a、(bitmap.colorType() != kAlpha_8_SkColorType && just_translate(matrix, bitmap))
kAlpha_8_SkColorType 的圖像只有一個通道alpha，按 drawMask 方式處理，將Paint中的顏色按圖像的alpha預乘，疊加到目標區域上。
just_translate表示matrix為一個平移矩陣，這時不涉及旋轉縮放，bitmap的像素點和SkCanvas綁定的dstBitmap的像素點此時存在連續的一一對齊關系。
b、clipHandlesSprite(*fRC, ix, iy, bitmap))
這個條件是指當前SkCanvas的裁剪區域不需要考慮抗鋸齒或者完全包含了bitmap的渲染區域。SkCanvas的任何渲染都必須在裁剪區域之內，因此如果圖像跨越了裁剪區域邊界而且裁剪區域需要考慮抗鋸齒，在邊界上需要做特殊處理。
注：裁剪區域的設置API
void SkCanvas::clipRect(const SkRect& rect, SkRegion::Op op, bool doAA)
doAA即是否在r的邊界非整數時考慮抗鋸齒。
滿足條件，創建SkSpriteBlitter，由SkScan::FillIRect按每個裁剪區域調用SkSpriteBlitter的blitRect。
這種情況下可以直接做顏色轉換和透明度合成渲染過去，不需要做抗鋸齒和圖像插值，也就不需要走取樣——混合流程，性能是最高的。


滿足條件后通過ChooseSprite去選一個SkSpriteBlitter
詳細代碼見 external/skia/src/core/SkBlitter_Sprite.cpp 中的 ChooseSprite 函數。
這函數實際上很多場景都沒覆蓋到，因此很可能是選不到的，這時就開始轉回drawRect流程。
（3）創建BitmapShader
在 ?SkAutoBitmapShaderInstall install(bitmap, paint); 這一句代碼中，為paint創建了bitmapShader：
? ? ? ? fPaint.setShader(CreateBitmapShader(src, SkShader::kClamp_TileMode,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? SkShader::kClamp_TileMode,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? localMatrix, &fAllocator));
然后就可以使用drawRect畫圖像了。


（4）drawRect
不能使用SkSpriteBlitter的場景，走drawRect通用流程。
這里有非常多的分支，只講繪制實矩形的情形。
通過 SkAutoBlitterChoose -> SkBlitter::Choose，根據Canvas綁定的Bitmap像素模式，paint屬性去選擇blitter。
繪制圖片時paint有Shader（SkBitmapProcShader），因此是選的是帶Shader的Blitter，比如適應ARGB格式的 SkARGB32_Shader_Blitter
（5）SkScan
在SkScan中，對每一個裁剪區域，將其與繪制的rect求交，然后渲染這個相交區域。此外，在需要時做抗鋸齒。
做抗鋸齒的基本方法就是對浮點的坐標，按其離整數的偏離度給一個alpha權重，將顏色乘以此權重（減淡顏色）畫上去。
SkScan中在繪制矩形時，先用blitV繪制左右邊界，再用blitAntiH繪制上下邊界，中間大塊的不需要考慮抗鋸齒，因而用blitRect。
（6）blitRect
這一步先通過 Shader的shadeSpan方法取對應位置的像素，再將此像素通過SkBlitRow的proc疊加上去。
如果不需要考慮混合模式，可以跳過proc。
參考代碼：external/skia/src/core/SkBlitter_ARGB32.cpp 中的blitRect
（7）shadeSpan
這里只考慮 SkBitmapProcShader 的shadeSpan，這主要是圖像采樣的方法。詳細代碼見 external/skia/src/core/SkBitmapProcShader.cpp
對每一個目標點，先通過 matrixProc 取出需要參考的源圖像素，然后用sampleProc將這些像素合成為一個像素值。（和OpenGL里面的texture2D函數原理很類似）。
若存在 shaderProc（做線性插值時，上面的步驟是可以優化的，完全可以取出一群像素一起做插值計算），以shaderProc代替上面的兩步流程，起性能優化作用。


3、SkBlitter接口解析
（1）blitH
virtual void blitH(int x, int y, int width);
從x,y坐標開始，渲染一行width個像素
（2）blitV
virtual void blitV(int x, int y, int height, SkAlpha alpha);
從x,y開始，渲染一列height個像素，按alpha值對顏色做減淡處理
（3）blitAntiH
virtual void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]);
如流程圖所標示的，這個函數的用來渲染上下邊界，作抗鋸齒處理。
（4）blitRect
virtual void blitRect(int x, int y, int width, int height);
繪制矩形區域，這個地方就不需要考慮任何的幾何變換、抗鋸齒等因素了。
（5）blitMask
virtual void blitMask(const SkMask& mask, const SkIRect& clip);
主要繪制文字時使用，以一個顏色乘上mash中的透明度，疊加。

一、采樣流程
我們先看一個具體的blitRect實現。

void SkARGB32_Shader_Blitter::blitRect(int x, int y, int width, int height) {
? ? SkASSERT(x >= 0 && y >= 0 &&
? ? ? ? ? ? ?x + width <= fDevice.width() && y + height <= fDevice.height());
? ? uint32_t* ? ? ? ? ?device = fDevice.getAddr32(x, y);
? ? size_t ? ? ? ? ? ? deviceRB = fDevice.rowBytes();
? ? SkShader::Context* shaderContext = fShaderContext;
? ? SkPMColor* ? ? ? ? span = fBuffer;
? ? if (fConstInY) {
? ? ? ? if (fShadeDirectlyIntoDevice) {
? ? ? ? ? ? // shade the first row directly into the device
? ? ? ? ? ? shaderContext->shadeSpan(x, y, device, width);
? ? ? ? ? ? span = device;
? ? ? ? ? ? while (--height > 0) {
? ? ? ? ? ? ? ? device = (uint32_t*)((char*)device + deviceRB);
? ? ? ? ? ? ? ? memcpy(device, span, width << 2);
? ? ? ? ? ? }
? ? ? ? } else {
? ? ? ? ? ? shaderContext->shadeSpan(x, y, span, width);
? ? ? ? ? ? SkXfermode* xfer = fXfermode;
? ? ? ? ? ? if (xfer) {
? ? ? ? ? ? ? ? do {
? ? ? ? ? ? ? ? ? ? xfer->xfer32(device, span, width, NULL);
? ? ? ? ? ? ? ? ? ? y += 1;
? ? ? ? ? ? ? ? ? ? device = (uint32_t*)((char*)device + deviceRB);
? ? ? ? ? ? ? ? } while (--height > 0);
? ? ? ? ? ? } else {
? ? ? ? ? ? ? ? SkBlitRow::Proc32 proc = fProc32;
? ? ? ? ? ? ? ? do {
? ? ? ? ? ? ? ? ? ? proc(device, span, width, 255);
? ? ? ? ? ? ? ? ? ? y += 1;
? ? ? ? ? ? ? ? ? ? device = (uint32_t*)((char*)device + deviceRB);
? ? ? ? ? ? ? ? } while (--height > 0);
? ? ? ? ? ? }
? ? ? ? }
? ? ? ? return;
? ? }
? ? if (fShadeDirectlyIntoDevice) {
? ? ? ? void* ctx;
? ? ? ? SkShader::Context::ShadeProc shadeProc = shaderContext->asAShadeProc(&ctx);
? ? ? ? if (shadeProc) {
? ? ? ? ? ? do {
? ? ? ? ? ? ? ? shadeProc(ctx, x, y, device, width);
? ? ? ? ? ? ? ? y += 1;
? ? ? ? ? ? ? ? device = (uint32_t*)((char*)device + deviceRB);
? ? ? ? ? ? } while (--height > 0);
? ? ? ? } else {
? ? ? ? ? ? do {
? ? ? ? ? ? ? ? shaderContext->shadeSpan(x, y, device, width);
? ? ? ? ? ? ? ? y += 1;
? ? ? ? ? ? ? ? device = (uint32_t*)((char*)device + deviceRB);
? ? ? ? ? ? } while (--height > 0);
? ? ? ? }
? ? } else {
? ? ? ? SkXfermode* xfer = fXfermode;
? ? ? ? if (xfer) {
? ? ? ? ? ? do {
? ? ? ? ? ? ? ? shaderContext->shadeSpan(x, y, span, width);
? ? ? ? ? ? ? ? xfer->xfer32(device, span, width, NULL);
? ? ? ? ? ? ? ? y += 1;
? ? ? ? ? ? ? ? device = (uint32_t*)((char*)device + deviceRB);
? ? ? ? ? ? } while (--height > 0);
? ? ? ? } else {
? ? ? ? ? ? SkBlitRow::Proc32 proc = fProc32;
? ? ? ? ? ? do {
? ? ? ? ? ? ? ? shaderContext->shadeSpan(x, y, span, width);
? ? ? ? ? ? ? ? proc(device, span, width, 255);
? ? ? ? ? ? ? ? y += 1;
? ? ? ? ? ? ? ? device = (uint32_t*)((char*)device + deviceRB);
? ? ? ? ? ? } while (--height > 0);
? ? ? ? }
? ? }
}

其中shadeSpan用來將shader中x，y坐標處的值取n個到dst的buffer中。對于圖像繪制時，它是 SkBitmapProcShader，這里是其實現：
void SkBitmapProcShader::BitmapProcShaderContext::shadeSpan(int x, int y, SkPMColor dstC[],
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? int count) {
? ? const SkBitmapProcState& state = *fState;
? ? if (state.getShaderProc32()) {
? ? ? ? state.getShaderProc32()(state, x, y, dstC, count);
? ? ? ? return;
? ? }


? ? uint32_t buffer[BUF_MAX + TEST_BUFFER_EXTRA];
? ? SkBitmapProcState::MatrixProc ? mproc = state.getMatrixProc();
? ? SkBitmapProcState::SampleProc32 sproc = state.getSampleProc32();
? ? int max = state.maxCountForBufferSize(sizeof(buffer[0]) * BUF_MAX);


? ? SkASSERT(state.fBitmap->getPixels());
? ? SkASSERT(state.fBitmap->pixelRef() == NULL ||
? ? ? ? ? ? ?state.fBitmap->pixelRef()->isLocked());


? ? for (;;) {
? ? ? ? int n = count;
? ? ? ? if (n > max) {
? ? ? ? ? ? n = max;
? ? ? ? }
? ? ? ? SkASSERT(n > 0 && n < BUF_MAX*2);
#ifdef TEST_BUFFER_OVERRITE
? ? ? ? for (int i = 0; i < TEST_BUFFER_EXTRA; i++) {
? ? ? ? ? ? buffer[BUF_MAX + i] = TEST_PATTERN;
? ? ? ? }
#endif
? ? ? ? mproc(state, buffer, n, x, y);
#ifdef TEST_BUFFER_OVERRITE
? ? ? ? for (int j = 0; j < TEST_BUFFER_EXTRA; j++) {
? ? ? ? ? ? SkASSERT(buffer[BUF_MAX + j] == TEST_PATTERN);
? ? ? ? }
#endif
? ? ? ? sproc(state, buffer, n, dstC);


? ? ? ? if ((count -= n) == 0) {
? ? ? ? ? ? break;
? ? ? ? }
? ? ? ? SkASSERT(count > 0);
? ? ? ? x += n;
? ? ? ? dstC += n;
? ? }
}

流程如下：
1、存在 shaderProc，直接用
2、計算一次能處理的像素數count
3、mproc計算count個坐標，sproc根據坐標值去取色
注意到之前三個函數指針：
state.getShaderProc32
mproc = state.getMatrixProc
sproc = state.getShaderProc32
這三個函數指針在一開始創建blitter時設定：

SkBlitter::Choose -> SkShader::createContext -> SkBitmapProcShader::onCreateContext -> SkBitmapProcState::chooseProcs

這是一個相當長的函數，它做的事情如下：
1、（優化步驟）在大于SkPaint::kLow_FilterLevel的質量要求下，試圖做預縮放。
2、選擇matrix函數：chooseMatrixProc。
3、選擇sample函數：
（1）高質量：setBitmapFilterProcs
（2）kLow_FilterLevel或kNone_FilterLevel：采取flags計算的方法,根據x,y變化矩陣情況和采樣要求選擇函數
4、（優化步驟）在滿足條件時，選取shader函數，此函數替代matrix和sample函數
5、（優化步驟）platformProcs()，進一步選擇優化版本的sample函數
對于RGB565格式的目標，使用的是SkShader的 shadeSpan16 方法。shadeSpan16的代碼邏輯類似，不再說明。

bool SkBitmapProcState::chooseProcs(const SkMatrix& inv, const SkPaint& paint) {
? ? SkASSERT(fOrigBitmap.width() && fOrigBitmap.height());
? ? fBitmap = NULL;
? ? fInvMatrix = inv;
? ? fFilterLevel = paint.getFilterLevel();
? ? SkASSERT(NULL == fScaledCacheID);
? ? // possiblyScaleImage will look to see if it can rescale the image as a
? ? // preprocess; either by scaling up to the target size, or by selecting
? ? // a nearby mipmap level. ?If it does, it will adjust the working
? ? // matrix as well as the working bitmap. ?It may also adjust the filter
? ? // quality to avoid re-filtering an already perfectly scaled image.
? ? if (!this->possiblyScaleImage()) {
? ? ? ? if (!this->lockBaseBitmap()) {
? ? ? ? ? ? return false;
? ? ? ? }
? ? }
? ? // The above logic should have always assigned fBitmap, but in case it
? ? // didn't, we check for that now...
? ? // TODO(dominikg): Ask humper@ if we can just use an SkASSERT(fBitmap)?
? ? if (NULL == fBitmap) {
? ? ? ? return false;
? ? }
? ? // If we are "still" kMedium_FilterLevel, then the request was not fulfilled by possiblyScale,
? ? // so we downgrade to kLow (so the rest of the sniffing code can assume that)
? ? if (SkPaint::kMedium_FilterLevel == fFilterLevel) {
? ? ? ? fFilterLevel = SkPaint::kLow_FilterLevel;
? ? }
? ? bool trivialMatrix = (fInvMatrix.getType() & ~SkMatrix::kTranslate_Mask) == 0;
? ? bool clampClamp = SkShader::kClamp_TileMode == fTileModeX &&
? ? ? ? ? ? ? ? ? ? ? SkShader::kClamp_TileMode == fTileModeY;
? ? if (!(clampClamp || trivialMatrix)) {
? ? ? ? fInvMatrix.postIDiv(fOrigBitmap.width(), fOrigBitmap.height());
? ? }
? ? // Now that all possible changes to the matrix have taken place, check
? ? // to see if we're really close to a no-scale matrix. ?If so, explicitly
? ? // set it to be so. ?Subsequent code may inspect this matrix to choose
? ? // a faster path in this case.
? ? // This code will only execute if the matrix has some scale component;
? ? // if it's already pure translate then we won't do this inversion.
? ? if (matrix_only_scale_translate(fInvMatrix)) {
? ? ? ? SkMatrix forward;
? ? ? ? if (fInvMatrix.invert(&forward)) {
? ? ? ? ? ? if (clampClamp ? just_trans_clamp(forward, *fBitmap)
? ? ? ? ? ? ? ? ? ? ? ? ? ? : just_trans_general(forward)) {
? ? ? ? ? ? ? ? SkScalar tx = -SkScalarRoundToScalar(forward.getTranslateX());
? ? ? ? ? ? ? ? SkScalar ty = -SkScalarRoundToScalar(forward.getTranslateY());
? ? ? ? ? ? ? ? fInvMatrix.setTranslate(tx, ty);
? ? ? ? ? ? }
? ? ? ? }
? ? }
? ? fInvProc ? ? ? ?= fInvMatrix.getMapXYProc();
? ? fInvType ? ? ? ?= fInvMatrix.getType();
? ? fInvSx ? ? ? ? ?= SkScalarToFixed(fInvMatrix.getScaleX());
? ? fInvSxFractionalInt = SkScalarToFractionalInt(fInvMatrix.getScaleX());
? ? fInvKy ? ? ? ? ?= SkScalarToFixed(fInvMatrix.getSkewY());
? ? fInvKyFractionalInt = SkScalarToFractionalInt(fInvMatrix.getSkewY());
? ? fAlphaScale = SkAlpha255To256(paint.getAlpha());
? ? fShaderProc32 = NULL;
? ? fShaderProc16 = NULL;
? ? fSampleProc32 = NULL;
? ? fSampleProc16 = NULL;
? ? // recompute the triviality of the matrix here because we may have
? ? // changed it!


? ? trivialMatrix = (fInvMatrix.getType() & ~SkMatrix::kTranslate_Mask) == 0;


? ? if (SkPaint::kHigh_FilterLevel == fFilterLevel) {
? ? ? ? // If this is still set, that means we wanted HQ sampling
? ? ? ? // but couldn't do it as a preprocess. ?Let's try to install
? ? ? ? // the scanline version of the HQ sampler. ?If that process fails,
? ? ? ? // downgrade to bilerp.


? ? ? ? // NOTE: Might need to be careful here in the future when we want
? ? ? ? // to have the platform proc have a shot at this; it's possible that
? ? ? ? // the chooseBitmapFilterProc will fail to install a shader but a
? ? ? ? // platform-specific one might succeed, so it might be premature here
? ? ? ? // to fall back to bilerp. ?This needs thought.


? ? ? ? if (!this->setBitmapFilterProcs()) {
? ? ? ? ? ? fFilterLevel = SkPaint::kLow_FilterLevel;
? ? ? ? }
? ? }


? ? if (SkPaint::kLow_FilterLevel == fFilterLevel) {
? ? ? ? // Only try bilerp if the matrix is "interesting" and
? ? ? ? // the image has a suitable size.


? ? ? ? if (fInvType <= SkMatrix::kTranslate_Mask ||
? ? ? ? ? ? ? ? !valid_for_filtering(fBitmap->width() | fBitmap->height())) {
? ? ? ? ? ? fFilterLevel = SkPaint::kNone_FilterLevel;
? ? ? ? }
? ? }


? ? // At this point, we know exactly what kind of sampling the per-scanline
? ? // shader will perform.


? ? fMatrixProc = this->chooseMatrixProc(trivialMatrix);
? ? // TODO(dominikg): SkASSERT(fMatrixProc) instead? chooseMatrixProc never returns NULL.
? ? if (NULL == fMatrixProc) {
? ? ? ? return false;
? ? }


? ? ///


? ? // No need to do this if we're doing HQ sampling; if filter quality is
? ? // still set to HQ by the time we get here, then we must have installed
? ? // the shader procs above and can skip all this.


? ? if (fFilterLevel < SkPaint::kHigh_FilterLevel) {


? ? ? ? int index = 0;
? ? ? ? if (fAlphaScale < 256) { ?// note: this distinction is not used for D16
? ? ? ? ? ? index |= 1;
? ? ? ? }
? ? ? ? if (fInvType <= (SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask)) {
? ? ? ? ? ? index |= 2;
? ? ? ? }
? ? ? ? if (fFilterLevel > SkPaint::kNone_FilterLevel) {
? ? ? ? ? ? index |= 4;
? ? ? ? }
? ? ? ? // bits 3,4,5 encoding the source bitmap format
? ? ? ? switch (fBitmap->colorType()) {
? ? ? ? ? ? case kN32_SkColorType:
? ? ? ? ? ? ? ? index |= 0;
? ? ? ? ? ? ? ? break;
? ? ? ? ? ? case kRGB_565_SkColorType:
? ? ? ? ? ? ? ? index |= 8;
? ? ? ? ? ? ? ? break;
? ? ? ? ? ? case kIndex_8_SkColorType:
? ? ? ? ? ? ? ? index |= 16;
? ? ? ? ? ? ? ? break;
? ? ? ? ? ? case kARGB_4444_SkColorType:
? ? ? ? ? ? ? ? index |= 24;
? ? ? ? ? ? ? ? break;
? ? ? ? ? ? case kAlpha_8_SkColorType:
? ? ? ? ? ? ? ? index |= 32;
? ? ? ? ? ? ? ? fPaintPMColor = SkPreMultiplyColor(paint.getColor());
? ? ? ? ? ? ? ? break;
? ? ? ? ? ? default:
? ? ? ? ? ? ? ? // TODO(dominikg): Should we ever get here? SkASSERT(false) instead?
? ? ? ? ? ? ? ? return false;
? ? ? ? }


? ? #if !SK_ARM_NEON_IS_ALWAYS
? ? ? ? static const SampleProc32 gSkBitmapProcStateSample32[] = {
? ? ? ? ? ? S32_opaque_D32_nofilter_DXDY,
? ? ? ? ? ? S32_alpha_D32_nofilter_DXDY,
? ? ? ? ? ? S32_opaque_D32_nofilter_DX,
? ? ? ? ? ? S32_alpha_D32_nofilter_DX,
? ? ? ? ? ? S32_opaque_D32_filter_DXDY,
? ? ? ? ? ? S32_alpha_D32_filter_DXDY,
? ? ? ? ? ? S32_opaque_D32_filter_DX,
? ? ? ? ? ? S32_alpha_D32_filter_DX,


? ? ? ? ? ? S16_opaque_D32_nofilter_DXDY,
? ? ? ? ? ? S16_alpha_D32_nofilter_DXDY,
? ? ? ? ? ? S16_opaque_D32_nofilter_DX,
? ? ? ? ? ? S16_alpha_D32_nofilter_DX,
? ? ? ? ? ? S16_opaque_D32_filter_DXDY,
? ? ? ? ? ? S16_alpha_D32_filter_DXDY,
? ? ? ? ? ? S16_opaque_D32_filter_DX,
? ? ? ? ? ? S16_alpha_D32_filter_DX,


? ? ? ? ? ? SI8_opaque_D32_nofilter_DXDY,
? ? ? ? ? ? SI8_alpha_D32_nofilter_DXDY,
? ? ? ? ? ? SI8_opaque_D32_nofilter_DX,
? ? ? ? ? ? SI8_alpha_D32_nofilter_DX,
? ? ? ? ? ? SI8_opaque_D32_filter_DXDY,
? ? ? ? ? ? SI8_alpha_D32_filter_DXDY,
? ? ? ? ? ? SI8_opaque_D32_filter_DX,
? ? ? ? ? ? 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
? ? ? ? };


? ? ? ? static const SampleProc16 gSkBitmapProcStateSample16[] = {
? ? ? ? ? ? S32_D16_nofilter_DXDY,
? ? ? ? ? ? S32_D16_nofilter_DX,
? ? ? ? ? ? S32_D16_filter_DXDY,
? ? ? ? ? ? S32_D16_filter_DX,


? ? ? ? ? ? S16_D16_nofilter_DXDY,
? ? ? ? ? ? S16_D16_nofilter_DX,
? ? ? ? ? ? S16_D16_filter_DXDY,
? ? ? ? ? ? S16_D16_filter_DX,


? ? ? ? ? ? SI8_D16_nofilter_DXDY,
? ? ? ? ? ? SI8_D16_nofilter_DX,
? ? ? ? ? ? SI8_D16_filter_DXDY,
? ? ? ? ? ? SI8_D16_filter_DX,


? ? ? ? ? ? // Don't support 4444 -> 565
? ? ? ? ? ? NULL, NULL, NULL, NULL,
? ? ? ? ? ? // Don't support A8 -> 565
? ? ? ? ? ? NULL, NULL, NULL, NULL
? ? ? ? };
? ? #endif


? ? ? ? fSampleProc32 = SK_ARM_NEON_WRAP(gSkBitmapProcStateSample32)[index];
? ? ? ? index >>= 1; ? ?// shift away any opaque/alpha distinction
? ? ? ? fSampleProc16 = SK_ARM_NEON_WRAP(gSkBitmapProcStateSample16)[index];


? ? ? ? // our special-case shaderprocs
? ? ? ? if (SK_ARM_NEON_WRAP(S16_D16_filter_DX) == fSampleProc16) {
? ? ? ? ? ? if (clampClamp) {
? ? ? ? ? ? ? ? fShaderProc16 = SK_ARM_NEON_WRAP(Clamp_S16_D16_filter_DX_shaderproc);
? ? ? ? ? ? } else if (SkShader::kRepeat_TileMode == fTileModeX &&
? ? ? ? ? ? ? ? ? ? ? ?SkShader::kRepeat_TileMode == fTileModeY) {
? ? ? ? ? ? ? ? fShaderProc16 = SK_ARM_NEON_WRAP(Repeat_S16_D16_filter_DX_shaderproc);
? ? ? ? ? ? }
? ? ? ? } else if (SK_ARM_NEON_WRAP(SI8_opaque_D32_filter_DX) == fSampleProc32 && clampClamp) {
? ? ? ? ? ? fShaderProc32 = SK_ARM_NEON_WRAP(Clamp_SI8_opaque_D32_filter_DX_shaderproc);
? ? ? ? }


? ? ? ? if (NULL == fShaderProc32) {
? ? ? ? ? ? fShaderProc32 = this->chooseShaderProc32();
? ? ? ? }
? ? }
? ? // see if our platform has any accelerated overrides
? ? this->platformProcs();
? ? return true;
}

二、MatrixProc和SampleProc
MatrixProc的使命是生成坐標集。SampleProc則根據坐標集取像素，采樣合成
我們先倒過來看 sampleProc 看這個坐標集是怎么使用的：
nofilter_dx系列：

void MAKENAME(_nofilter_DXDY)(const SkBitmapProcState& s,
? ? ? ? const uint32_t* SK_RESTRICT xy,
? ? ? ? int count, DSTTYPE* SK_RESTRICT colors) {
? ? for (int i = (count >> 1); i > 0; --i) {
? ? ? ? XY = *xy++;
? ? ? ? SkASSERT((XY >> 16) < (unsigned)s.fBitmap->height() &&
? ? ? ? ? ? ? ? (XY & 0xFFFF) < (unsigned)s.fBitmap->width());
? ? ? ? src = ((const SRCTYPE*)(srcAddr + (XY >> 16) * rb))[XY & 0xFFFF];
? ? ? ? *colors++ = RETURNDST(src);


? ? ? ? XY = *xy++;
? ? ? ? SkASSERT((XY >> 16) < (unsigned)s.fBitmap->height() &&
? ? ? ? ? ? ? ? (XY & 0xFFFF) < (unsigned)s.fBitmap->width());
? ? ? ? src = ((const SRCTYPE*)(srcAddr + (XY >> 16) * rb))[XY & 0xFFFF];
? ? ? ? *colors++ = RETURNDST(src);
? ? }
? ? if (count & 1) {
? ? ? ? XY = *xy++;
? ? ? ? SkASSERT((XY >> 16) < (unsigned)s.fBitmap->height() &&
? ? ? ? ? ? ? ? (XY & 0xFFFF) < (unsigned)s.fBitmap->width());
? ? ? ? src = ((const SRCTYPE*)(srcAddr + (XY >> 16) * rb))[XY & 0xFFFF];
? ? ? ? *colors++ = RETURNDST(src);
? ? }
}

這兩個系列是直接取了x,y坐標處的圖像像素
filter_dx系列：

filter_dxdy系列：

void MAKENAME(_filter_DX)(const SkBitmapProcState& s,
? ? ? ? ? ? ? ? ? ? ? ? ? const uint32_t* SK_RESTRICT xy,
? ? ? ? ? ? ? ? ? ? ? ? ? ?int count, DSTTYPE* SK_RESTRICT colors) {
? ? SkASSERT(count > 0 && colors != NULL);
? ? SkASSERT(s.fFilterLevel != SkPaint::kNone_FilterLevel);
? ? SkDEBUGCODE(CHECKSTATE(s);)


#ifdef PREAMBLE
? ? PREAMBLE(s);
#endif
? ? const char* SK_RESTRICT srcAddr = (const char*)s.fBitmap->getPixels();
? ? size_t rb = s.fBitmap->rowBytes();
? ? unsigned subY;
? ? const SRCTYPE* SK_RESTRICT row0;
? ? const SRCTYPE* SK_RESTRICT row1;


? ? // setup row ptrs and update proc_table
? ? {
? ? ? ? uint32_t XY = *xy++;
? ? ? ? unsigned y0 = XY >> 14;
? ? ? ? row0 = (const SRCTYPE*)(srcAddr + (y0 >> 4) * rb);
? ? ? ? row1 = (const SRCTYPE*)(srcAddr + (XY & 0x3FFF) * rb);
? ? ? ? subY = y0 & 0xF;
? ? }


? ? do {
? ? ? ? uint32_t XX = *xy++; ? ?// x0:14 | 4 | x1:14
? ? ? ? unsigned x0 = XX >> 14;
? ? ? ? unsigned x1 = XX & 0x3FFF;
? ? ? ? unsigned subX = x0 & 0xF;
? ? ? ? x0 >>= 4;


? ? ? ? FILTER_PROC(subX, subY,
? ? ? ? ? ? ? ? ? ? SRC_TO_FILTER(row0[x0]),
? ? ? ? ? ? ? ? ? ? SRC_TO_FILTER(row0[x1]),
? ? ? ? ? ? ? ? ? ? SRC_TO_FILTER(row1[x0]),
? ? ? ? ? ? ? ? ? ? SRC_TO_FILTER(row1[x1]),
? ? ? ? ? ? ? ? ? ? colors);
? ? ? ? colors += 1;


? ? } while (--count != 0);


#ifdef POSTAMBLE
? ? POSTAMBLE(s);
#endif
}
void MAKENAME(_filter_DXDY)(const SkBitmapProcState& s,
? ? ? ? ? ? ? ? ? ? ? ? ? ? const uint32_t* SK_RESTRICT xy,
? ? ? ? ? ? ? ? ? ? ? ? ? ? int count, DSTTYPE* SK_RESTRICT colors) {
? ? SkASSERT(count > 0 && colors != NULL);
? ? SkASSERT(s.fFilterLevel != SkPaint::kNone_FilterLevel);
? ? SkDEBUGCODE(CHECKSTATE(s);)


#ifdef PREAMBLE
? ? ? ? PREAMBLE(s);
#endif
? ? const char* SK_RESTRICT srcAddr = (const char*)s.fBitmap->getPixels();
? ? size_t rb = s.fBitmap->rowBytes();


? ? do {
? ? ? ? uint32_t data = *xy++;
? ? ? ? unsigned y0 = data >> 14;
? ? ? ? unsigned y1 = data & 0x3FFF;
? ? ? ? unsigned subY = y0 & 0xF;
? ? ? ? y0 >>= 4;


? ? ? ? data = *xy++;
? ? ? ? unsigned x0 = data >> 14;
? ? ? ? unsigned x1 = data & 0x3FFF;
? ? ? ? unsigned subX = x0 & 0xF;
? ? ? ? x0 >>= 4;


? ? ? ? const SRCTYPE* SK_RESTRICT row0 = (const SRCTYPE*)(srcAddr + y0 * rb);
? ? ? ? const SRCTYPE* SK_RESTRICT row1 = (const SRCTYPE*)(srcAddr + y1 * rb);


? ? ? ? FILTER_PROC(subX, subY,
? ? ? ? ? ? ? ? ? ? SRC_TO_FILTER(row0[x0]),
? ? ? ? ? ? ? ? ? ? SRC_TO_FILTER(row0[x1]),
? ? ? ? ? ? ? ? ? ? SRC_TO_FILTER(row1[x0]),
? ? ? ? ? ? ? ? ? ? SRC_TO_FILTER(row1[x1]),
? ? ? ? ? ? ? ? ? ? colors);
? ? ? ? colors += 1;
? ? } while (--count != 0);


#ifdef POSTAMBLE
? ? POSTAMBLE(s);
#endif
}

將四個相鄰像素取出來之后，作Filter處理

看暈了么，其實總結一下是這樣：
nofilter_dx，第一個32位數表示y，其余的32位數包含兩個x坐標。
nofilter_dxdy，用16位表示x，16位表示y。這種情況就是取的最近值，直接到x,y坐標處取值就可以了。
filter_dxdy系列，每個32位數分別表示X和Y坐標（14:4:14），交錯排列，中間的差值部分是相差的小數擴大16倍而得的近似整數。
filter_dx系列，第一個數為Y坐標用14:4:14的方式存儲，后面的數為X坐標，也用14:4:14的方式存儲，前后為對應坐標，中間為放大16倍的距離，這個情況是一行之內y坐標相同（只做縮放或小數平移的情況），一樣是作雙線性插值。

下面我們來看matrixproc的實現，

先跟進 chooseMatrixProc的代碼：

SkBitmapProcState::MatrixProc SkBitmapProcState::chooseMatrixProc(bool trivial_matrix) {
// ? ?test_int_tileprocs();
? ? // check for our special case when there is no scale/affine/perspective
? ? if (trivial_matrix) {
? ? ? ? SkASSERT(SkPaint::kNone_FilterLevel == fFilterLevel);
? ? ? ? fIntTileProcY = choose_int_tile_proc(fTileModeY);
? ? ? ? switch (fTileModeX) {
? ? ? ? ? ? case SkShader::kClamp_TileMode:
? ? ? ? ? ? ? ? return clampx_nofilter_trans;
? ? ? ? ? ? case SkShader::kRepeat_TileMode:
? ? ? ? ? ? ? ? return repeatx_nofilter_trans;
? ? ? ? ? ? case SkShader::kMirror_TileMode:
? ? ? ? ? ? ? ? return mirrorx_nofilter_trans;
? ? ? ? }
? ? }


? ? int index = 0;
? ? if (fFilterLevel != SkPaint::kNone_FilterLevel) {
? ? ? ? index = 1;
? ? }
? ? if (fInvType & SkMatrix::kPerspective_Mask) {
? ? ? ? index += 4;
? ? } else if (fInvType & SkMatrix::kAffine_Mask) {
? ? ? ? index += 2;
? ? }


? ? if (SkShader::kClamp_TileMode == fTileModeX && SkShader::kClamp_TileMode == fTileModeY) {
? ? ? ? // clamp gets special version of filterOne
? ? ? ? fFilterOneX = SK_Fixed1;
? ? ? ? fFilterOneY = SK_Fixed1;
? ? ? ? return SK_ARM_NEON_WRAP(ClampX_ClampY_Procs)[index];
? ? }


? ? // all remaining procs use this form for filterOne
? ? fFilterOneX = SK_Fixed1 / fBitmap->width();
? ? fFilterOneY = SK_Fixed1 / fBitmap->height();


? ? if (SkShader::kRepeat_TileMode == fTileModeX && SkShader::kRepeat_TileMode == fTileModeY) {
? ? ? ? return SK_ARM_NEON_WRAP(RepeatX_RepeatY_Procs)[index];
? ? }


? ? fTileProcX = choose_tile_proc(fTileModeX);
? ? fTileProcY = choose_tile_proc(fTileModeY);
? ? fTileLowBitsProcX = choose_tile_lowbits_proc(fTileModeX);
? ? fTileLowBitsProcY = choose_tile_lowbits_proc(fTileModeY);
? ? return GeneralXY_Procs[index];
}

有些函數是找符號找不到的，我們注意到SkBitmapProcState.cpp 中包含了多次 SkBitmapProcState_matrix.h 頭文件：

#if !SK_ARM_NEON_IS_ALWAYS
#define MAKENAME(suffix) ? ? ? ?ClampX_ClampY ## suffix
#define TILEX_PROCF(fx, max) ? ?SkClampMax((fx) >> 16, max)
#define TILEY_PROCF(fy, max) ? ?SkClampMax((fy) >> 16, max)
#define TILEX_LOW_BITS(fx, max) (((fx) >> 12) & 0xF)
#define TILEY_LOW_BITS(fy, max) (((fy) >> 12) & 0xF)
#define CHECK_FOR_DECAL
#include "SkBitmapProcState_matrix.h"

/*
?* 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 "SkMath.h"
#include "SkMathPriv.h"


#define SCALE_FILTER_NAME ? ? ? MAKENAME(_filter_scale)
#define AFFINE_FILTER_NAME ? ? ?MAKENAME(_filter_affine)
#define PERSP_FILTER_NAME ? ? ? MAKENAME(_filter_persp)


#define PACK_FILTER_X_NAME ?MAKENAME(_pack_filter_x)
#define PACK_FILTER_Y_NAME ?MAKENAME(_pack_filter_y)


#ifndef PREAMBLE
? ? #define PREAMBLE(state)
? ? #define PREAMBLE_PARAM_X
? ? #define PREAMBLE_PARAM_Y
? ? #define PREAMBLE_ARG_X
? ? #define PREAMBLE_ARG_Y
#endif


// declare functions externally to suppress warnings.
void SCALE_FILTER_NAME(const SkBitmapProcState& s,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? uint32_t xy[], int count, int x, int y);
void AFFINE_FILTER_NAME(const SkBitmapProcState& s,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?uint32_t xy[], int count, int x, int y);
void PERSP_FILTER_NAME(const SkBitmapProcState& s,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? uint32_t* SK_RESTRICT xy, int count,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? int x, int y);


static inline uint32_t PACK_FILTER_Y_NAME(SkFixed f, unsigned max,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? SkFixed one PREAMBLE_PARAM_Y) {
? ? unsigned i = TILEY_PROCF(f, max);
? ? i = (i << 4) | TILEY_LOW_BITS(f, max);
? ? return (i << 14) | (TILEY_PROCF((f + one), max));
}


static inline uint32_t PACK_FILTER_X_NAME(SkFixed f, unsigned max,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? SkFixed one PREAMBLE_PARAM_X) {
? ? unsigned i = TILEX_PROCF(f, max);
? ? i = (i << 4) | TILEX_LOW_BITS(f, max);
? ? return (i << 14) | (TILEX_PROCF((f + one), max));
}


void SCALE_FILTER_NAME(const SkBitmapProcState& s,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? uint32_t xy[], int count, int x, int y) {
? ? SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask |
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?SkMatrix::kScale_Mask)) == 0);
? ? SkASSERT(s.fInvKy == 0);


? ? PREAMBLE(s);


? ? const unsigned maxX = s.fBitmap->width() - 1;
? ? const SkFixed one = s.fFilterOneX;
? ? const SkFractionalInt dx = s.fInvSxFractionalInt;
? ? SkFractionalInt fx;


? ? {
? ? ? ? SkPoint pt;
? ? ? ? s.fInvProc(s.fInvMatrix, SkIntToScalar(x) + SK_ScalarHalf,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? SkIntToScalar(y) + SK_ScalarHalf, &pt);
? ? ? ? const SkFixed fy = SkScalarToFixed(pt.fY) - (s.fFilterOneY >> 1);
? ? ? ? const unsigned maxY = s.fBitmap->height() - 1;
? ? ? ? // compute our two Y values up front
? ? ? ? *xy++ = PACK_FILTER_Y_NAME(fy, maxY, s.fFilterOneY PREAMBLE_ARG_Y);
? ? ? ? // now initialize fx
? ? ? ? fx = SkScalarToFractionalInt(pt.fX) - (SkFixedToFractionalInt(one) >> 1);
? ? }


#ifdef CHECK_FOR_DECAL
? ? if (can_truncate_to_fixed_for_decal(fx, dx, count, maxX)) {
? ? ? ? decal_filter_scale(xy, SkFractionalIntToFixed(fx),
? ? ? ? ? ? ? ? ? ? ? ? ? ?SkFractionalIntToFixed(dx), count);
? ? } else
#endif
? ? {
? ? ? ? do {
? ? ? ? ? ? SkFixed fixedFx = SkFractionalIntToFixed(fx);
? ? ? ? ? ? *xy++ = PACK_FILTER_X_NAME(fixedFx, maxX, one PREAMBLE_ARG_X);
? ? ? ? ? ? fx += dx;
? ? ? ? } while (--count != 0);
? ? }
}


void AFFINE_FILTER_NAME(const SkBitmapProcState& s,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?uint32_t xy[], int count, int x, int y) {
? ? SkASSERT(s.fInvType & SkMatrix::kAffine_Mask);
? ? SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask |
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?SkMatrix::kScale_Mask |
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?SkMatrix::kAffine_Mask)) == 0);


? ? PREAMBLE(s);
? ? SkPoint srcPt;
? ? s.fInvProc(s.fInvMatrix,
? ? ? ? ? ? ? ?SkIntToScalar(x) + SK_ScalarHalf,
? ? ? ? ? ? ? ?SkIntToScalar(y) + SK_ScalarHalf, &srcPt);


? ? SkFixed oneX = s.fFilterOneX;
? ? SkFixed oneY = s.fFilterOneY;
? ? SkFixed fx = SkScalarToFixed(srcPt.fX) - (oneX >> 1);
? ? SkFixed fy = SkScalarToFixed(srcPt.fY) - (oneY >> 1);
? ? SkFixed dx = s.fInvSx;
? ? SkFixed dy = s.fInvKy;
? ? unsigned maxX = s.fBitmap->width() - 1;
? ? unsigned maxY = s.fBitmap->height() - 1;


? ? do {
? ? ? ? *xy++ = PACK_FILTER_Y_NAME(fy, maxY, oneY PREAMBLE_ARG_Y);
? ? ? ? fy += dy;
? ? ? ? *xy++ = PACK_FILTER_X_NAME(fx, maxX, oneX PREAMBLE_ARG_X);
? ? ? ? fx += dx;
? ? } while (--count != 0);
}


void PERSP_FILTER_NAME(const SkBitmapProcState& s,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? uint32_t* SK_RESTRICT xy, int count,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? int x, int y) {
? ? SkASSERT(s.fInvType & SkMatrix::kPerspective_Mask);


? ? PREAMBLE(s);
? ? unsigned maxX = s.fBitmap->width() - 1;
? ? unsigned maxY = s.fBitmap->height() - 1;
? ? SkFixed oneX = s.fFilterOneX;
? ? SkFixed oneY = s.fFilterOneY;


? ? SkPerspIter ? iter(s.fInvMatrix,
? ? ? ? ? ? ? ? ? ? ? ?SkIntToScalar(x) + SK_ScalarHalf,
? ? ? ? ? ? ? ? ? ? ? ?SkIntToScalar(y) + SK_ScalarHalf, count);


? ? while ((count = iter.next()) != 0) {
? ? ? ? const SkFixed* SK_RESTRICT srcXY = iter.getXY();
? ? ? ? do {
? ? ? ? ? ? *xy++ = PACK_FILTER_Y_NAME(srcXY[1] - (oneY >> 1), maxY,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?oneY PREAMBLE_ARG_Y);
? ? ? ? ? ? *xy++ = PACK_FILTER_X_NAME(srcXY[0] - (oneX >> 1), maxX,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?oneX PREAMBLE_ARG_X);
? ? ? ? ? ? srcXY += 2;
? ? ? ? } while (--count != 0);
? ? }
}


#undef MAKENAME
#undef TILEX_PROCF
#undef TILEY_PROCF
#ifdef CHECK_FOR_DECAL
? ? #undef CHECK_FOR_DECAL
#endif


#undef SCALE_FILTER_NAME
#undef AFFINE_FILTER_NAME
#undef PERSP_FILTER_NAME


#undef PREAMBLE
#undef PREAMBLE_PARAM_X
#undef PREAMBLE_PARAM_Y
#undef PREAMBLE_ARG_X
#undef PREAMBLE_ARG_Y


#undef TILEX_LOW_BITS
#undef TILEY_LOW_BITS

然后我們就清楚了，這些函數名是用宏組合出來的。（神一般的代碼。。。。。）
怎么算坐標的不詳述了，主要按原理去推就可以了，坐標計算有三種模式：CLAMP（越界時限制在邊界）、REPEAT（越界時從開頭取起）、MIRROR（越界時取樣方向倒轉去取）。
sampleProc函數也是類似的方法組合出來的，不詳述。


三、高級插值算法
雙線性插值雖然在一般情況下夠用了，但在放大圖片時，效果還是不夠好。需要更好的效果，可以用高級插值算法，代價是性能的大幅消耗。
高級插值算法目前在Android的Java代碼處是走不進去的，不知道chromium是否用到。
幾個要點：
1、在 setBitmapFilterProcs 時判斷高級插值是否支持，若支持，設置 shaderProc 為 highQualityFilter32/highQualityFilter16（也就是獨立計算坐標和采樣像素）
2、highQualityFilter先通過變換矩陣計算原始點。
3、highQualityFilter根據 SkBitmapFilter ?的采樣窗口，將這個窗口中的所有點按其與原始點矩離，查詢對應權重值，然后相加，得到最終像素點。
4、SkBitmapFilter 采用查表法去給出權重值，預計算由子類完成。
5、目前Skia庫用的是雙三次插值 mitchell 法。

SK_CONF_DECLARE(const char *, c_bitmapFilter, "bitmap.filter", "mitchell", "Which scanline bitmap filter to use [mitchell, lanczos, hamming, gaussian, triangle, box]");
詳細代碼見 external/skia/src/core/SkBitmapFilter.cpp，盡量這部分代碼幾乎無用武之地，但里面的公式很值得借鑒，隨便改改就能做成 glsl shader 用。

看完這段代碼，可以作不負責任的猜想：Skia設計之初，只考慮了近鄰插值和雙線性插值兩種情況，因此采用這種模板方法，可以最小化代碼量。而且MatrixProc和SampleProc可以后續分別作SIMD優化（Intel的SSE和ARM的Neon），以提高性能。
但是對于線性插值，兩步法（取值——采樣）在算法實現上本來就不是最優的，后面又不得不引入shader函數，應對一些場景做優化。高階插值無法在這個設計下實現，因此又像補丁一樣打上去。

四、總結
看完這一部分代碼，有三個感受。
第一：繪張圖片看上去一件簡單的事，在渲染執行時，真心不容易，如果追求效果，還會有各種各樣的花樣。
第二：在性能有要求的場景下，用模板真是災難：函數改寫時，遇到模板，就不得不重新定義函數，并替換之，弄得代碼看上去一下子混亂不少。
第三：從圖像繪制這個角度上看，skia渲染性能雖然確實很好了，但遠沒有達到極限，仍然是有一定的優化空間的，如果這部分出現了性能問題，還是能做一定的優化的。關于Skia性能的討論將放到介紹Skia系列的最后一章。
第四：OpenGL+glsl確實是輕松且高效多了，軟件渲染在復雜場景上性能很有限。

總結

以上是生活随笔為你收集整理的Skia深入分析的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。