SurfaceFlinger旋转流程分析

chipset: MSM8X25Q

codebase: Android4.1

本文主要对SF(SurfaceFilnger)处理旋转事件的流程做个简单分析。GPU和mdp都可以用来旋转，文中对两者穿插说明。

系统初始化会调用GraphicPlane::setDisplayHardware，此函数主要判断系统是否默认设置了rotation property值，如果有，则先保存下来。另外，SF是以transform其实就是以矩阵来作旋转计算的，计算方法以线性代数中的知识为依据：

void GraphicPlane::setDisplayHardware(DisplayHardware *hw)
{
    mHw = hw;

    // initialize the display orientation transform.
    // it's a constant that should come from the display driver.
    int displayOrientation = ISurfaceComposer::eOrientationDefault;
    char property[PROPERTY_VALUE_MAX];
    /*读取property*/
    if (property_get("ro.sf.hwrotation", property, NULL)  > 0) {
        //displayOrientation
        switch (atoi(property)) {
        /*当然，你也可以仿照添加180°的旋转。*/
        case 90:
            displayOrientation = ISurfaceComposer::eOrientation90;
            break;
        case 270:
            displayOrientation =  ISurfaceComposer::eOrientation270;
            break;
        }
    }


    const float w = hw->getWidth();
    const float h =  hw->getHeight();
    /*根据宽和高以及orientation生成一个transform*/
    GraphicPlane::orientationToTransfrom(displayOrientation, w, h,
            &mDisplayTransform);
    /*90°或者270°时需要变换宽高。*/
    if (displayOrientation & ISurfaceComposer::eOrientationSwapMask) {
        mDisplayWidth = h;
        mDisplayHeight = w;
    } else {
        mDisplayWidth = w;
        mDisplayHeight = h;
    }

    /*保存当前全局旋转角度，意味着整个系统的显示都要根据整个值
来得出最后是否要旋转。如果为90°或者270°，那就是横屏，如果
是180°，画面就要反转180°。*/
    setOrientation(ISurfaceComposer::eOrientationDefault);
}

status_t GraphicPlane::setOrientation(int orientation)
{
    // If the rotation can be handled in hardware, this is where
    // the magic should happen.

    const DisplayHardware& hw(displayHardware());
    const float w = mDisplayWidth;
    const float h =  mDisplayHeight;
    mWidth = int(w);
    mHeight = int(h);

    Transform orientationTransform;
    GraphicPlane::orientationToTransfrom(orientation, w, h,
            &orientationTransform);
    if (orientation & ISurfaceComposer::eOrientationSwapMask) {
        mWidth =  int(h);
        mHeight = int(w);
    }

    mOrientation =  orientation;
    /*将orientation和h/w计算和得出一个全局的transform，这里的
相乘计算方法，就是利用矩阵来实现的。*/
    mGlobalTransform = mDisplayTransform * orientationTransform;
    return NO_ERROR;
}

void GraphicPlane::setDisplayHardware(DisplayHardware *hw)
{
    mHw = hw;

    // initialize the display orientation transform.
    // it's a constant that should come from the display driver.
    int displayOrientation = ISurfaceComposer::eOrientationDefault;
    char property[PROPERTY_VALUE_MAX];
	/*读取property*/
    if (property_get("ro.sf.hwrotation", property, NULL) > 0) {
        //displayOrientation
        switch (atoi(property)) {
		/*当然，你也可以仿照添加180°的旋转。*/
        case 90:
            displayOrientation = ISurfaceComposer::eOrientation90;
            break;
        case 270:
            displayOrientation = ISurfaceComposer::eOrientation270;
            break;
        }
    }


    const float w = hw->getWidth();
    const float h = hw->getHeight();
	/*根据宽和高以及orientation生成一个transform*/
    GraphicPlane::orientationToTransfrom(displayOrientation, w, h,
            &mDisplayTransform);
	/*90°或者270°时需要变换宽高。*/
    if (displayOrientation & ISurfaceComposer::eOrientationSwapMask) {
        mDisplayWidth = h;
        mDisplayHeight = w;
    } else {
        mDisplayWidth = w;
        mDisplayHeight = h;
    }

	/*保存当前全局旋转角度，意味着整个系统的显示都要根据整个值
来得出最后是否要旋转。如果为90°或者270°，那就是横屏，如果
是180°，画面就要反转180°。*/
    setOrientation(ISurfaceComposer::eOrientationDefault);
}

status_t GraphicPlane::setOrientation(int orientation)
{
    // If the rotation can be handled in hardware, this is where
    // the magic should happen.

    const DisplayHardware& hw(displayHardware());
    const float w = mDisplayWidth;
    const float h = mDisplayHeight;
    mWidth = int(w);
    mHeight = int(h);

    Transform orientationTransform;
    GraphicPlane::orientationToTransfrom(orientation, w, h,
            &orientationTransform);
    if (orientation & ISurfaceComposer::eOrientationSwapMask) {
        mWidth = int(h);
        mHeight = int(w);
    }

    mOrientation = orientation;
	/*将orientation和h/w计算和得出一个全局的transform，这里的
相乘计算方法，就是利用矩阵来实现的。*/
    mGlobalTransform = mDisplayTransform * orientationTransform;
    return NO_ERROR;
}

由于整个系统一直默认旋转只是流程中一个坐标的特殊处理，不管系统上层是否请求旋转，如横屏游戏，sensor坐标变化，默认的旋转是一直会被处理的。

注意别把这两种旋转混淆了，默认旋转是一般情况下用户看到的显示效果，而上层apk

请求的旋转相对默认旋转是瞬间的。

         现在以上层发生旋转事件为例看下SF处理旋转的流程。

上层调用SurfaceFlinger::setTransactionState设置当前角度变化了：

void SurfaceFlinger::setTransactionState(const Vector<ComposerState>& state,
        int orientation, uint32_t flags) {
    Mutex::Autolock _l(mStateLock);

uint32_t transactionFlags = 0;

/*当前坐标和要设置的坐标不相等表明要作旋转了！*/
    if (mCurrentState.orientation != orientation) {
        if (uint32_t(orientation)<=eOrientation270 || orientation==42) {
            mCurrentState.orientation = orientation;
            transactionFlags |= eTransactionNeeded;
        } else if (orientation != eOrientationUnchanged) {
            ALOGW("setTransactionState: ignoring unrecognized orientation: %d",
                    orientation);
        }
    }

    /*设置旋转标志，SF处理的时候会用到。*/
    const size_t count = state.size();
    for (size_t i=0 ; i<count ; i++) {
        const ComposerState& s(state[i]);
        sp<Client> client( static_cast<Client *>(s.client.get()) );
        transactionFlags |= setClientStateLocked(client, s.state);
    }

    if (transactionFlags) {
        // this triggers the transaction
        setTransactionFlags(transactionFlags);

~~snip
}

void SurfaceFlinger::setTransactionState(const Vector<ComposerState>& state,
        int orientation, uint32_t flags) {
    Mutex::Autolock _l(mStateLock);

uint32_t transactionFlags = 0;

/*当前坐标和要设置的坐标不相等表明要作旋转了！*/
    if (mCurrentState.orientation != orientation) {
        if (uint32_t(orientation)<=eOrientation270 || orientation==42) {
            mCurrentState.orientation = orientation;
            transactionFlags |= eTransactionNeeded;
        } else if (orientation != eOrientationUnchanged) {
            ALOGW("setTransactionState: ignoring unrecognized orientation: %d",
                    orientation);
        }
    }

	/*设置旋转标志，SF处理的时候会用到。*/
    const size_t count = state.size();
    for (size_t i=0 ; i<count ; i++) {
        const ComposerState& s(state[i]);
        sp<Client> client( static_cast<Client *>(s.client.get()) );
        transactionFlags |= setClientStateLocked(client, s.state);
    }

    if (transactionFlags) {
        // this triggers the transaction
        setTransactionFlags(transactionFlags);

~~snip
}

SF收到消息后，调用SurfaceFlinger::onMessageReceived进行处理，核心的部分都在这里了。

void SurfaceFlinger::onMessageReceived(int32_t what)
{
    ATRACE_CALL();
    switch (what) {
        case MessageQueue::INVALIDATE:
        case MessageQueue::REFRESH: {
//        case MessageQueue::INVALIDATE: {
            // if we're in a global transaction, don't do anything.
            const uint32_t mask = eTransactionNeeded | eTraversalNeeded;
            uint32_t transactionFlags = peekTransactionFlags(mask);
/*处理事务*/
            if (CC_UNLIKELY(transactionFlags)) {
                handleTransaction(transactionFlags);
            }

            const uint32_t mask1 = eDelayedTraversalNeeded;
            uint32_t transactionFlags1 = peekTransactionFlags(mask1);
            if (CC_UNLIKELY(transactionFlags1)) {
                handleDelayedTransaction(transactionFlags);
            }
            /*计算可视区域*/
            // post surfaces (if needed)
            handlePageFlip();

~~snip
      case MessageQueue::REFRESH: {

~~snip
            /*处理几何坐标*/
            if (CC_UNLIKELY(mHwWorkListDirty)) {
                // build the h/w work list
                handleWorkList();
            }

            /*render*/
            if (CC_LIKELY(hw.canDraw())) {
                // repaint the framebuffer (if needed)
                handleRepaint();
                // inform the h/w that we're done compositing
                hw.compositionComplete();
                postFramebuffer();
            } else {
                // pretend we did the post
                hw.compositionComplete();
            }

        } break;
    }
}

void SurfaceFlinger::onMessageReceived(int32_t what)
{
    ATRACE_CALL();
    switch (what) {
        case MessageQueue::INVALIDATE:
        case MessageQueue::REFRESH: {
//        case MessageQueue::INVALIDATE: {
            // if we're in a global transaction, don't do anything.
            const uint32_t mask = eTransactionNeeded | eTraversalNeeded;
            uint32_t transactionFlags = peekTransactionFlags(mask);
/*处理事务*/
            if (CC_UNLIKELY(transactionFlags)) {
                handleTransaction(transactionFlags);
            }

            const uint32_t mask1 = eDelayedTraversalNeeded;
            uint32_t transactionFlags1 = peekTransactionFlags(mask1);
            if (CC_UNLIKELY(transactionFlags1)) {
                handleDelayedTransaction(transactionFlags);
            }
			/*计算可视区域*/
            // post surfaces (if needed)
            handlePageFlip();

~~snip
      case MessageQueue::REFRESH: {

~~snip
			/*处理几何坐标*/
            if (CC_UNLIKELY(mHwWorkListDirty)) {
                // build the h/w work list
                handleWorkList();
            }
			
			/*render*/
            if (CC_LIKELY(hw.canDraw())) {
                // repaint the framebuffer (if needed)
                handleRepaint();
                // inform the h/w that we're done compositing
                hw.compositionComplete();
                postFramebuffer();
            } else {
                // pretend we did the post
                hw.compositionComplete();
            }

        } break;
    }
}

下面一一对这几个函数分析。

handleTransaction

void SurfaceFlinger::handleTransaction(uint32_t transactionFlags)
{
~~snip

    const uint32_t mask = eTransactionNeeded | eTraversalNeeded;
    transactionFlags = getTransactionFlags(mask);
    handleTransactionLocked(transactionFlags);
~~snip
}

void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags)
{
    const LayerVector& currentLayers(mCurrentState.layersSortedByZ);
    const size_t count = currentLayers.size();

    /*
     * Traversal of the children
     * (perform the transaction for each of them if needed)
     */
    /*判断是否有事务要处理。*/
    const bool layersNeedTransaction = transactionFlags & eTraversalNeeded;
    if (layersNeedTransaction) {
        for (size_t i=0 ; i<count ; i++) {
            const sp<LayerBase>& layer = currentLayers[i];
            uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
            if (!trFlags) continue;

            const uint32_t flags = layer->doTransaction(0);
            if (flags & Layer::eVisibleRegion)
                mVisibleRegionsDirty = true;
        }
    }
~~snip

if (transactionFlags & eTransactionNeeded) {
        /*有旋转角度变化的事务。*/
        if (mCurrentState.orientation != mDrawingState.orientation) {
            // the orientation has changed, recompute all visible regions
            // and invalidate everything.

            const int dpy = 0;
            const int orientation = mCurrentState.orientation;
            // Currently unused: const uint32_t  flags = mCurrentState.orientationFlags;
            GraphicPlane& plane(graphicPlane(dpy));
            /*根据当前旋转的坐标，还有默认的旋转坐标，计算和得出最终全局transform。
此函数前面分析过了。*/
            plane.setOrientation(orientation);
            const Transform& planeTransform(plane.transform());

            // update the shared control block
            const DisplayHardware& hw(plane.displayHardware());
            volatile display_cblk_t* dcblk = mServerCblk->displays + dpy;
            dcblk->orientation = orientation;
            dcblk->w = plane.getWidth();
            dcblk->h = plane.getHeight();

            /*旋转过后当然要重新绘制显示画面了，设置标志。*/
            mVisibleRegionsDirty = true;
            mDirtyRegion.set(hw.bounds());
        }

~~snip
}

void SurfaceFlinger::handleTransaction(uint32_t transactionFlags)
{
~~snip

    const uint32_t mask = eTransactionNeeded | eTraversalNeeded;
    transactionFlags = getTransactionFlags(mask);
    handleTransactionLocked(transactionFlags);
~~snip
}

void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags)
{
    const LayerVector& currentLayers(mCurrentState.layersSortedByZ);
    const size_t count = currentLayers.size();

    /*
     * Traversal of the children
     * (perform the transaction for each of them if needed)
     */
	/*判断是否有事务要处理。*/
    const bool layersNeedTransaction = transactionFlags & eTraversalNeeded;
    if (layersNeedTransaction) {
        for (size_t i=0 ; i<count ; i++) {
            const sp<LayerBase>& layer = currentLayers[i];
            uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
            if (!trFlags) continue;

            const uint32_t flags = layer->doTransaction(0);
            if (flags & Layer::eVisibleRegion)
                mVisibleRegionsDirty = true;
        }
    }
~~snip

if (transactionFlags & eTransactionNeeded) {
		/*有旋转角度变化的事务。*/
        if (mCurrentState.orientation != mDrawingState.orientation) {
            // the orientation has changed, recompute all visible regions
            // and invalidate everything.

            const int dpy = 0;
            const int orientation = mCurrentState.orientation;
            // Currently unused: const uint32_t flags = mCurrentState.orientationFlags;
            GraphicPlane& plane(graphicPlane(dpy));
			/*根据当前旋转的坐标，还有默认的旋转坐标，计算和得出最终全局transform。
此函数前面分析过了。*/
            plane.setOrientation(orientation);
            const Transform& planeTransform(plane.transform());

            // update the shared control block
            const DisplayHardware& hw(plane.displayHardware());
            volatile display_cblk_t* dcblk = mServerCblk->displays + dpy;
            dcblk->orientation = orientation;
            dcblk->w = plane.getWidth();
            dcblk->h = plane.getHeight();

			/*旋转过后当然要重新绘制显示画面了，设置标志。*/
            mVisibleRegionsDirty = true;
            mDirtyRegion.set(hw.bounds());
        }

~~snip
}

可见handleTransaction主要设置全局的transform。

handlePageFlip

void SurfaceFlinger::handlePageFlip()
{
    ATRACE_CALL();
    const DisplayHardware& hw =  graphicPlane(0).displayHardware();
    const Region screenRegion(hw.bounds());

    const LayerVector& currentLayers(mDrawingState.layersSortedByZ);
    const bool visibleRegions =  lockPageFlip(currentLayers);

        if (visibleRegions || mVisibleRegionsDirty) {
            Region opaqueRegion;
            /*有旋转过，所以要重新计算可视区域*/
            computeVisibleRegions(currentLayers, mDirtyRegion, opaqueRegion);
~~snip
}
~~snip

}

void SurfaceFlinger::computeVisibleRegions(
    const LayerVector& currentLayers, Region& dirtyRegion, Region& opaqueRegion)
{
    ATRACE_CALL();

    const GraphicPlane& plane(graphicPlane(0));
    const Transform& planeTransform(plane.transform());
    const DisplayHardware& hw(plane.displayHardware());
    const Region screenRegion(hw.bounds());

    Region aboveOpaqueLayers;
    Region aboveCoveredLayers;
    Region dirty;

    bool secureFrameBuffer =  false;

    size_t i = currentLayers.size();
    while (i--) {
        const sp<LayerBase>& layer = currentLayers[i];
        /*将全局的transform传进去，然后调用各个layer作计算。*/
        layer->validateVisibility(planeTransform);

      ~~snip
}
}

void LayerBase::validateVisibility(const Transform& planeTransform)
{
const Layer::State& s(drawingState());
/*全局transform和当前layer的transform相乘计算得到一个transform.*/
    const Transform tr(planeTransform * s.transform);
    const bool transformed = tr.transformed();
    const DisplayHardware& hw(graphicPlane(0).displayHardware());
    const uint32_t hw_h = hw.getHeight();
    const Rect& crop(s.active.crop);

    Rect win(s.active.w, s.active.h);
    if (!crop.isEmpty()) {
        win.intersect(crop, &win);
    }

mNumVertices =  4;
/* mVertices 相当重要，系统根据当前的transform还有当前layer的
区域作计算，当然也包含了全局的transform信息在里面，计算出来的
坐标保存到了mVertices 去。要注意，mVertices 只是给GPU用的，如果
用mdp做旋转，SF后面的流程会对其做相应设置。*/
    tr.transform(mVertices[0], win.left,  win.top);
    tr.transform(mVertices[1], win.left,  win.bottom);
    tr.transform(mVertices[2], win.right, win.bottom);
    tr.transform(mVertices[3], win.right, win.top);
    for (size_t i=0 ; i<4 ; i++)
        mVertices[i][1] = hw_h - mVertices[i][1];

    if (CC_UNLIKELY(transformed)) {
        // NOTE: here we could also punt if we have too many rectangles
        // in the transparent region
    /*根据transform对透明区域作处理。*/
        if (tr.preserveRects()) {
            // transform the transparent region
            transparentRegionScreen = tr.transform(s.transparentRegion);
        } else {
            // transformation too complex, can't do the transparent region
            // optimization.
            transparentRegionScreen.clear();
        }
    } else {
        transparentRegionScreen =  s.transparentRegion;
    }

    /*保存相应的一些信息到新的参数变量中，以便后面用到。*/
    // cache a few things...
    mOrientation =  tr.getOrientation();
    mPlaneOrientation = planeTransform.getOrientation();
    mTransform =  tr;
    mTransformedBounds = tr.transform(win);
}

void SurfaceFlinger::handlePageFlip()
{
    ATRACE_CALL();
    const DisplayHardware& hw = graphicPlane(0).displayHardware();
    const Region screenRegion(hw.bounds());

    const LayerVector& currentLayers(mDrawingState.layersSortedByZ);
    const bool visibleRegions = lockPageFlip(currentLayers);

        if (visibleRegions || mVisibleRegionsDirty) {
            Region opaqueRegion;
			/*有旋转过，所以要重新计算可视区域*/
            computeVisibleRegions(currentLayers, mDirtyRegion, opaqueRegion);
~~snip
}
~~snip

}

void SurfaceFlinger::computeVisibleRegions(
    const LayerVector& currentLayers, Region& dirtyRegion, Region& opaqueRegion)
{
    ATRACE_CALL();

    const GraphicPlane& plane(graphicPlane(0));
    const Transform& planeTransform(plane.transform());
    const DisplayHardware& hw(plane.displayHardware());
    const Region screenRegion(hw.bounds());

    Region aboveOpaqueLayers;
    Region aboveCoveredLayers;
    Region dirty;

    bool secureFrameBuffer = false;

    size_t i = currentLayers.size();
    while (i--) {
        const sp<LayerBase>& layer = currentLayers[i];
		/*将全局的transform传进去，然后调用各个layer作计算。*/
        layer->validateVisibility(planeTransform);
	
      ~~snip
}
}

void LayerBase::validateVisibility(const Transform& planeTransform)
{
const Layer::State& s(drawingState());
/*全局transform和当前layer的transform相乘计算得到一个transform.*/
    const Transform tr(planeTransform * s.transform);
    const bool transformed = tr.transformed();
    const DisplayHardware& hw(graphicPlane(0).displayHardware());
    const uint32_t hw_h = hw.getHeight();
    const Rect& crop(s.active.crop);

    Rect win(s.active.w, s.active.h);
    if (!crop.isEmpty()) {
        win.intersect(crop, &win);
    }

mNumVertices = 4;
/* mVertices 相当重要，系统根据当前的transform还有当前layer的
区域作计算，当然也包含了全局的transform信息在里面，计算出来的
坐标保存到了mVertices 去。要注意，mVertices 只是给GPU用的，如果
用mdp做旋转，SF后面的流程会对其做相应设置。*/
    tr.transform(mVertices[0], win.left,  win.top);
    tr.transform(mVertices[1], win.left,  win.bottom);
    tr.transform(mVertices[2], win.right, win.bottom);
    tr.transform(mVertices[3], win.right, win.top);
    for (size_t i=0 ; i<4 ; i++)
        mVertices[i][1] = hw_h - mVertices[i][1];

    if (CC_UNLIKELY(transformed)) {
        // NOTE: here we could also punt if we have too many rectangles
        // in the transparent region
	/*根据transform对透明区域作处理。*/
        if (tr.preserveRects()) {
            // transform the transparent region
            transparentRegionScreen = tr.transform(s.transparentRegion);
        } else {
            // transformation too complex, can't do the transparent region
            // optimization.
            transparentRegionScreen.clear();
        }
    } else {
        transparentRegionScreen = s.transparentRegion;
    }

	/*保存相应的一些信息到新的参数变量中，以便后面用到。*/
    // cache a few things...
    mOrientation = tr.getOrientation();
    mPlaneOrientation = planeTransform.getOrientation();
    mTransform = tr;
    mTransformedBounds = tr.transform(win);
}

可见，从handlePageFlip中，我们主要是得到了GPU要处理的坐标，保存到了mVertices数组中。

handleWorkList

void SurfaceFlinger::handleWorkList()
{
    mHwWorkListDirty = false;
    HWComposer& hwc(graphicPlane(0).displayHardware().getHwComposer());
    if (hwc.initCheck() == NO_ERROR) {
        const Vector< sp<LayerBase> >& currentLayers(mVisibleLayersSortedByZ);
        const size_t count = currentLayers.size();
        hwc.createWorkList(count);
        hwc_layer_t* const cur(hwc.getLayers());
        for (size_t i=0 ; cur && i<count ; i++) {
            /*依次调用各个layer的setGeometry 。*/
            currentLayers[i]->setGeometry(&cur[i]);
        }
    }
}

void Layer::setGeometry(hwc_layer_t* hwcl)
{
    /*调用基类函数。*/
    LayerBaseClient::setGeometry(hwcl);

    hwcl->flags &= ~HWC_SKIP_LAYER;

    /*不完全透明时需要GPU处理。*/
    // we can't do alpha-fade with the hwc HAL
    const State& s(drawingState());
    if (s.alpha < 0xFF) {
        hwcl->flags = HWC_SKIP_LAYER;
    }

    /*
     * Transformations are applied in this order:
     * 1) buffer orientation/flip/mirror
     * 2) state transformation (window manager)
     * 3) layer orientation (screen orientation)
     * mTransform is already the composition of (2) and (3)
     * (NOTE: the matrices are multiplied in reverse order)
     */

    /*这里就是在根据要求的旋转信息得出最终的transform，
然后赋值给hwcl，hwcl的信息最后会传给mdp处理。*/
    const Transform bufferOrientation(mCurrentTransform);
    hwcl->sourceTransform = bufferOrientation.getOrientation();
    const Transform tr(mTransform * bufferOrientation);

    // this gives us only the "orientation" component of the transform
    const uint32_t finalTransform = tr.getOrientation();

    // we can only handle simple transformation
    if (finalTransform & Transform::ROT_INVALID) {
        hwcl->flags = HWC_SKIP_LAYER;
    } else {
        hwcl->transform = finalTransform;
    }
    /*得到layer区域相对坐标，绝对坐标在基类中计算得到。*/
Rect crop = computeBufferCrop();
    hwcl->sourceCrop.left   = crop.left;
    hwcl->sourceCrop.top    = crop.top;
    hwcl->sourceCrop.right  = crop.right;
    hwcl->sourceCrop.bottom = crop.bottom;
}

void SurfaceFlinger::handleWorkList()
{
    mHwWorkListDirty = false;
    HWComposer& hwc(graphicPlane(0).displayHardware().getHwComposer());
    if (hwc.initCheck() == NO_ERROR) {
        const Vector< sp<LayerBase> >& currentLayers(mVisibleLayersSortedByZ);
        const size_t count = currentLayers.size();
        hwc.createWorkList(count);
        hwc_layer_t* const cur(hwc.getLayers());
        for (size_t i=0 ; cur && i<count ; i++) {
			/*依次调用各个layer的setGeometry 。*/
            currentLayers[i]->setGeometry(&cur[i]);
        }
    }
}

void Layer::setGeometry(hwc_layer_t* hwcl)
{
	/*调用基类函数。*/
    LayerBaseClient::setGeometry(hwcl);

    hwcl->flags &= ~HWC_SKIP_LAYER;

	/*不完全透明时需要GPU处理。*/
    // we can't do alpha-fade with the hwc HAL
    const State& s(drawingState());
    if (s.alpha < 0xFF) {
        hwcl->flags = HWC_SKIP_LAYER;
    }

    /*
     * Transformations are applied in this order:
     * 1) buffer orientation/flip/mirror
     * 2) state transformation (window manager)
     * 3) layer orientation (screen orientation)
     * mTransform is already the composition of (2) and (3)
     * (NOTE: the matrices are multiplied in reverse order)
     */
	
	/*这里就是在根据要求的旋转信息得出最终的transform，
然后赋值给hwcl，hwcl的信息最后会传给mdp处理。*/
    const Transform bufferOrientation(mCurrentTransform);
    hwcl->sourceTransform = bufferOrientation.getOrientation();
    const Transform tr(mTransform * bufferOrientation);

    // this gives us only the "orientation" component of the transform
    const uint32_t finalTransform = tr.getOrientation();

    // we can only handle simple transformation
    if (finalTransform & Transform::ROT_INVALID) {
        hwcl->flags = HWC_SKIP_LAYER;
    } else {
        hwcl->transform = finalTransform;
    }
	/*得到layer区域相对坐标，绝对坐标在基类中计算得到。*/
Rect crop = computeBufferCrop();
	hwcl->sourceCrop.left   = crop.left;
    hwcl->sourceCrop.top    = crop.top;
    hwcl->sourceCrop.right  = crop.right;
    hwcl->sourceCrop.bottom = crop.bottom;
}

由此看来handleWorkList主要是服务于mdp的，如果用GPU旋转的话可以不需要这些信息。

handleRepaint

void SurfaceFlinger::handleRepaint()
{
~~snip
setupHardwareComposer();
    /*对各个layer作render*/
    composeSurfaces(mDirtyRegion);

    // update the swap region and clear the dirty region
    mSwapRegion.orSelf(mDirtyRegion);
    mDirtyRegion.clear();
}

void SurfaceFlinger::composeSurfaces(const Region& dirty)
{
    const DisplayHardware& hw(graphicPlane(0).displayHardware());
    HWComposer& hwc(hw.getHwComposer());
    hwc_layer_t* const cur(hwc.getLayers());

    const size_t fbLayerCount = hwc.getLayerCount(HWC_FRAMEBUFFER);
    if (!cur || fbLayerCount) {
~~snip
        const Vector< sp<LayerBase> >& layers(mVisibleLayersSortedByZ);
        const size_t count = layers.size();

        for (size_t i=0 ; i<count ; i++) {
            const sp<LayerBase>& layer(layers[i]);
            const Region clip(dirty.intersect(layer->visibleRegionScreen));
~~snip
        /*如果不是HWC_FRAMEBUFFER 类型的话不处理，也就是让mdp去做处理。*/
#ifdef QCOMHW
                if (cur && (cur[i].compositionType != HWC_FRAMEBUFFER))
                    continue;
#endif
            /*依次调用各种layer的draw函数 */
                // render the layer
                layer->draw(clip);
            }
        }
   ~~snip
}

void LayerBase::draw(const Region& clip) const
{
    //Dont draw External-only layers
    if (isLayerExternalOnly(getLayer())) {
        return;
    }
    onDraw(clip);
}

void Layer::onDraw(const Region& clip) const
{
~~snip
    /*画图*/
    drawWithOpenGL(clip);

    glDisable(GL_TEXTURE_EXTERNAL_OES);
    glDisable(GL_TEXTURE_2D);
}

void LayerBase::drawWithOpenGL(const Region& clip) const
{
    const DisplayHardware& hw(graphicPlane(0).displayHardware());
    const uint32_t fbHeight =  hw.getHeight();
    const State& s(drawingState());

~~snip

    struct TexCoords {
        GLfloat u;
        GLfloat v;
    };

    Rect crop(s.active.w, s.active.h);
    if (!s.active.crop.isEmpty()) {
        crop = s.active.crop;
    }
    GLfloat left = GLfloat(crop.left) / GLfloat(s.active.w);
    GLfloat top =  GLfloat(crop.top) / GLfloat(s.active.h);
    GLfloat right = GLfloat(crop.right) / GLfloat(s.active.w);
    GLfloat bottom =  GLfloat(crop.bottom) / GLfloat(s.active.h);
    /*得到顶点坐标*/
    TexCoords texCoords[4];
    texCoords[0].u = left;
    texCoords[0].v =  top;
    texCoords[1].u = left;
    texCoords[1].v =  bottom;
    texCoords[2].u = right;
    texCoords[2].v =  bottom;
    texCoords[3].u = right;
    texCoords[3].v =  top;
    for (int i = 0; i < 4; i++) {
        texCoords[i].v = 1.0f - texCoords[i].v;
    }

    /*OpenGL利用下面这些函数将根据纹理坐标和顶点坐标
得到最后layer的显示区域以及内容。*/
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    glVertexPointer(2, GL_FLOAT, 0, mVertices);
    glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
    glDrawArrays(GL_TRIANGLE_FAN, 0, mNumVertices);

    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
    glDisable(GL_BLEND);
}

void SurfaceFlinger::handleRepaint()
{
~~snip
setupHardwareComposer();
	/*对各个layer作render*/
    composeSurfaces(mDirtyRegion);

    // update the swap region and clear the dirty region
    mSwapRegion.orSelf(mDirtyRegion);
    mDirtyRegion.clear();
}

void SurfaceFlinger::composeSurfaces(const Region& dirty)
{
    const DisplayHardware& hw(graphicPlane(0).displayHardware());
    HWComposer& hwc(hw.getHwComposer());
    hwc_layer_t* const cur(hwc.getLayers());

    const size_t fbLayerCount = hwc.getLayerCount(HWC_FRAMEBUFFER);
    if (!cur || fbLayerCount) {
~~snip
        const Vector< sp<LayerBase> >& layers(mVisibleLayersSortedByZ);
        const size_t count = layers.size();

        for (size_t i=0 ; i<count ; i++) {
            const sp<LayerBase>& layer(layers[i]);
            const Region clip(dirty.intersect(layer->visibleRegionScreen));
~~snip
		/*如果不是HWC_FRAMEBUFFER 类型的话不处理，也就是让mdp去做处理。*/
#ifdef QCOMHW
                if (cur && (cur[i].compositionType != HWC_FRAMEBUFFER))
                    continue;
#endif
			/*依次调用各种layer的draw函数 */
                // render the layer
                layer->draw(clip);
            }
        }
   ~~snip
}

void LayerBase::draw(const Region& clip) const
{
    //Dont draw External-only layers
    if (isLayerExternalOnly(getLayer())) {
        return;
    }
    onDraw(clip);
}

void Layer::onDraw(const Region& clip) const
{
~~snip
	/*画图*/
    drawWithOpenGL(clip);

    glDisable(GL_TEXTURE_EXTERNAL_OES);
    glDisable(GL_TEXTURE_2D);
}

void LayerBase::drawWithOpenGL(const Region& clip) const
{
    const DisplayHardware& hw(graphicPlane(0).displayHardware());
    const uint32_t fbHeight = hw.getHeight();
    const State& s(drawingState());

~~snip

    struct TexCoords {
        GLfloat u;
        GLfloat v;
    };

    Rect crop(s.active.w, s.active.h);
    if (!s.active.crop.isEmpty()) {
        crop = s.active.crop;
    }
    GLfloat left = GLfloat(crop.left) / GLfloat(s.active.w);
    GLfloat top = GLfloat(crop.top) / GLfloat(s.active.h);
    GLfloat right = GLfloat(crop.right) / GLfloat(s.active.w);
    GLfloat bottom = GLfloat(crop.bottom) / GLfloat(s.active.h);
	/*得到顶点坐标*/
    TexCoords texCoords[4];
    texCoords[0].u = left;
    texCoords[0].v = top;
    texCoords[1].u = left;
    texCoords[1].v = bottom;
    texCoords[2].u = right;
    texCoords[2].v = bottom;
    texCoords[3].u = right;
    texCoords[3].v = top;
    for (int i = 0; i < 4; i++) {
        texCoords[i].v = 1.0f - texCoords[i].v;
    }

  	/*OpenGL利用下面这些函数将根据纹理坐标和顶点坐标
得到最后layer的显示区域以及内容。*/
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    glVertexPointer(2, GL_FLOAT, 0, mVertices);
    glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
    glDrawArrays(GL_TRIANGLE_FAN, 0, mNumVertices);

    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
    glDisable(GL_BLEND);
}

所以，composeSurfaces是服务于GPU的。

虽然mdp已经旋转完成了，但是似乎还没有看到如何送给mdp啊？看看postFramebuffer.

  postFramebuffer

void SurfaceFlinger::postFramebuffer()
{
~~snip

    const DisplayHardware& hw(graphicPlane(0).displayHardware());
    const nsecs_t now = systemTime();
    mDebugInSwapBuffers = now;
    hw.flip(mSwapRegion);
~~snip
}
void DisplayHardware::flip(const Region& dirty) const
{
~~snip

    if (mHwc->initCheck() == NO_ERROR) {
        mHwc->commit();
    } else {
        eglSwapBuffers(dpy, surface);
    }
~~snip
}

status_t HWComposer::commit() const {
    /*调用了HAL的set，看起来和硬件有关联了！*/
    int err = mHwc->set(mHwc, mDpy, mSur, ((mSwapRectOn)?mListDirty:mList));
    if (mSwapRectOn && mListDirty) {
        mListDirty->flags &= ~HWC_GEOMETRY_CHANGED;
    } else if ( mList) {
        mList->flags &= ~HWC_GEOMETRY_CHANGED;
    }
    return (status_t)err;
}
static int hwc_set(hwc_composer_device_t *dev,
                   hwc_display_t dpy,
                   hwc_surface_t sur,
                   hwc_layer_list_t* list)
{
    int ret = 0;
    hwc_context_t* ctx = (hwc_context_t*)(dev);
    if (LIKELY(list)) {
        VideoOverlay::draw(ctx, list);
        ExtOnly::draw(ctx, list);
        CopyBit::draw(ctx, list, (EGLDisplay)dpy, (EGLSurface)sur);
        /*调用到mdp的draw了！！！*/
        MDPComp::draw(ctx, list);
        EGLBoolean sucess =  eglSwapBuffers((EGLDisplay)dpy, (EGLSurface)sur);
      ~~snip
}
    return ret;
}

void SurfaceFlinger::postFramebuffer()
{
~~snip

    const DisplayHardware& hw(graphicPlane(0).displayHardware());
    const nsecs_t now = systemTime();
    mDebugInSwapBuffers = now;
    hw.flip(mSwapRegion);
~~snip
}
void DisplayHardware::flip(const Region& dirty) const
{
~~snip

    if (mHwc->initCheck() == NO_ERROR) {
        mHwc->commit();
    } else {
        eglSwapBuffers(dpy, surface);
    }
~~snip
}

status_t HWComposer::commit() const {
	/*调用了HAL的set，看起来和硬件有关联了！*/
    int err = mHwc->set(mHwc, mDpy, mSur, ((mSwapRectOn)?mListDirty:mList));
    if (mSwapRectOn && mListDirty) {
        mListDirty->flags &= ~HWC_GEOMETRY_CHANGED;
    } else if ( mList) {
        mList->flags &= ~HWC_GEOMETRY_CHANGED;
    }
    return (status_t)err;
}
static int hwc_set(hwc_composer_device_t *dev,
                   hwc_display_t dpy,
                   hwc_surface_t sur,
                   hwc_layer_list_t* list)
{
    int ret = 0;
    hwc_context_t* ctx = (hwc_context_t*)(dev);
    if (LIKELY(list)) {
        VideoOverlay::draw(ctx, list);
        ExtOnly::draw(ctx, list);
        CopyBit::draw(ctx, list, (EGLDisplay)dpy, (EGLSurface)sur);
		/*调用到mdp的draw了！！！*/
        MDPComp::draw(ctx, list);
        EGLBoolean sucess = eglSwapBuffers((EGLDisplay)dpy, (EGLSurface)sur);
      ~~snip
}
    return ret;
}

总的下来，流程还是比较清晰的，不过里面很多transform很容易把人给弄晕掉，可以加log看值跟踪下。

2013/02/17