原文出處：http://blog.csdn.net/hgl868/article/details/45583667
一、渲染層級
從渲染流程上分，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確實是輕鬆且高效多了，軟件渲染在複雜場景上性能很有限。
