Android6.0 图像合成过程详解（一） setUpHWComposer函数


http://blog.csdn.net/kc58236582/article/details/52856341


上一篇博客分析了，用户进程如何申请一个GraphicBuffer的过程。这篇博客我们进一步分析图像合成过程，其中也解答之前的一些疑惑：

1. 之前碰到的不支持硬件模块

2. DisplayDevice类

3. 消费者的onFrameAvailable函数

我们直接分析合成的过程，具体的流程我们http://blog.csdn.net/kc58236582/article/details/52778333这篇博客分析了，这篇博客我们增加了一些以前没理解的点。


一、handleTransactionLocked函数

1.1 Layer的doTransaction函数

这里我直接从handleTransactionLocked函数开始分析，这个函数先会调用每个Layer对象的doTransaction函数，我们先来看看这个函数。

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. uint32_t Layer::doTransaction(uint32_t flags) {  
  2.     ATRACE_CALL();  
  3.   
  4.     const Layer::State& s(getDrawingState());//上次绘制的State对象  
  5.     const Layer::State& c(getCurrentState());//当前使用的State对象  
  6.   
  7.     const bool sizeChanged = (c.requested.w != s.requested.w) ||//如果两个对象的大小不相等，说明Layer的尺寸发生变化  
  8.                              (c.requested.h != s.requested.h);  
  9.   
  10.     if (sizeChanged) {//如果Layer的尺寸发生变化，就要改变Surface的缓冲区的尺寸  
  11.         mSurfaceFlingerConsumer->setDefaultBufferSize(  
  12.                 c.requested.w, c.requested.h);  
  13.     }  
  14.   
  15.     if (!isFixedSize()) {  
  16.         //如果Layer不是固定尺寸的类型，比较它的实际大小和要求的改变大小  
  17.         const bool resizePending = (c.requested.w != c.active.w) ||  
  18.                                    (c.requested.h != c.active.h);  
  19.   
  20.         if (resizePending && mSidebandStream == NULL) {//如果两者不一样，flags加上不更新Geometry标志  
  21.             flags |= eDontUpdateGeometryState;  
  22.         }  
  23.     }  
  24.   
  25.     if (flags & eDontUpdateGeometryState)  {  
  26.     } else {  
  27.         //如果没有eDontUpdateGeometryState标志，更新active的值为request  
  28.         Layer::State& editCurrentState(getCurrentState());  
  29.         editCurrentState.active = c.requested;  
  30.     }  
  31.   
  32.     if (s.active != c.active) {  
  33.         // 如果当前state的active和以前的State的active不等，设置更新标志  
  34.         flags |= Layer::eVisibleRegion;  
  35.     }  
  36.   
  37.     if (c.sequence != s.sequence) {  
  38.         //如果当前state的sequence和以前state的sequence不等，设置更新标志  
  39.         flags |= eVisibleRegion;  
  40.         this->contentDirty = true;  
  41.   
  42.         const uint8_t type = c.transform.getType();  
  43.         mNeedsFiltering = (!c.transform.preserveRects() ||  
  44.                 (type >= Transform::SCALE));  
  45.     }  
  46.   
  47.     // Commit the transaction  
  48.     commitTransaction();//将mCurrentState的值赋给mDrawingState  
  49.     return flags;  
  50. }  

这个函数之前博客也分析过，这里我们看看其中最重要的一个flag就是eVisibleRegion代表这个Layer是否要更新。而这里如果要更新Layer，也只是大小，sequence（也就是属性）变化才会更新这个flag。而Layer内容（buffer）的更新不在这里。这里使用了mDrawingState，mCurrentState两个变量。这两个变量主要是一些属性值。

最后会把mCurrentState的值赋给mDrawingState。而mCurrentState是在下面一些函数中变化的：

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. bool Layer::setPosition(float x, float y) {  
  2.     if (mCurrentState.transform.tx() == x && mCurrentState.transform.ty() == y)  
  3.         return false;  
  4.     mCurrentState.sequence++;  
  5.     mCurrentState.transform.set(x, y);  
  6.     setTransactionFlags(eTransactionNeeded);  
  7.     return true;  
  8. }  
  9. bool Layer::setLayer(uint32_t z) {  
  10.     if (mCurrentState.z == z)  
  11.         return false;  
  12.     mCurrentState.sequence++;  
  13.     mCurrentState.z = z;  
  14.     setTransactionFlags(eTransactionNeeded);  
  15.     return true;  
  16. }  
  17. bool Layer::setSize(uint32_t w, uint32_t h) {  
  18.     if (mCurrentState.requested.w == w && mCurrentState.requested.h == h)  
  19.         return false;  
  20.     mCurrentState.requested.w = w;  
  21.     mCurrentState.requested.h = h;  
  22.     setTransactionFlags(eTransactionNeeded);  
  23.     return true;  
  24. }  
  25. bool Layer::setAlpha(uint8_t alpha) {  
  26.     if (mCurrentState.alpha == alpha)  
  27.         return false;  
  28.     mCurrentState.sequence++;  
  29.     mCurrentState.alpha = alpha;  
  30.     setTransactionFlags(eTransactionNeeded);  
  31.     return true;  
  32. }  

我们下面开始看handleTransactionLocked函数。

先看下处理layer的事务，遍历每个Layer的doTransaction来更新状态，以及根据flags是否要更新layer。

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags)  
  2. {  
  3.     const LayerVector& currentLayers(mCurrentState.layersSortedByZ);//所有的Layer  
  4.     const size_t count = currentLayers.size();  
  5.   
  6.     /* 
  7.      * Traversal of the children 
  8.      * (perform the transaction for each of them if needed) 
  9.      */  
  10.   
  11.     if (transactionFlags & eTraversalNeeded) {  
  12.         for (size_t i=0 ; i<count ; i++) {  
  13.             const sp<Layer>& layer(currentLayers[i]);  
  14.             uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);  
  15.             if (!trFlags) continue;  
  16.   
  17.             const uint32_t flags = layer->doTransaction(0);//遍历每个layer,更新mDrawingState状态  
  18.             if (flags & Layer::eVisibleRegion)  
  19.                 mVisibleRegionsDirty = true;//有需要更新的layer,把该变量置为true  
  20.         }  
  21.     }  

1.2 处理显示设备的变化

下面是handleTransactionLocked中处理显示设备的变化的

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. if (transactionFlags & eDisplayTransactionNeeded) {  
  2.     //得到当前显示设备列表和之前使用的显示设备列表  
  3.     const KeyedVector<  wp<IBinder>, DisplayDeviceState>& curr(mCurrentState.displays);  
  4.     const KeyedVector<  wp<IBinder>, DisplayDeviceState>& draw(mDrawingState.displays);  
  5.     if (!curr.isIdenticalTo(draw)) {  
  6.         mVisibleRegionsDirty = true;  
  7.         const size_t cc = curr.size();//现在显示设备的数量  
  8.               size_t dc = draw.size();//以前显示设备的数量  
  9.   
  10.         for (size_t i=0 ; i<dc ; i++) {  
  11.             const ssize_t j = curr.indexOfKey(draw.keyAt(i));  
  12.             if (j < 0) {//j< 0代表当前设备列表中找不到以前设备列表中的某个设备，设备被删除了  
  13.                 if (!draw[i].isMainDisplay()) {  
  14.                     ......  
  15.                     //如果不是主设备移除它  
  16.                     mDisplays.removeItem(draw.keyAt(i));  
  17.                 } else {  
  18.                     ALOGW("trying to remove the main display");  
  19.                 }  
  20.             } else {//j>0代表这个设备两个列表中都存在，再检查有没有其他变化  
  21.                 // this display is in both lists. see if something changed.  
  22.                 const DisplayDeviceState& state(curr[j]);  
  23.                 const wp<IBinder>& display(curr.keyAt(j));  
  24.                 const sp<IBinder> state_binder = IInterface::asBinder(state.surface);  
  25.                 const sp<IBinder> draw_binder = IInterface::asBinder(draw[i].surface);  
  26.                 if (state_binder != draw_binder) {  
  27.                     //设备的Surface已经发生了变化（Surface对象不是一个了），旧的设备必须先删除掉  
  28.                     sp<DisplayDevice> hw(getDisplayDevice(display));  
  29.                     if (hw != NULL)  
  30.                         hw->disconnect(getHwComposer());  
  31.                     mDisplays.removeItem(display);  
  32.                     mDrawingState.displays.removeItemsAt(i);  
  33.                     dc--; i--;  
  34.                     // at this point we must loop to the next item  
  35.                     continue;  
  36.                 }  
  37.   
  38.                 const sp<DisplayDevice> disp(getDisplayDevice(display));  
  39.                 if (disp != NULL) {  
  40.                     //两个对象的layerStack不相等，使用当前对象的  
  41.                     if (state.layerStack != draw[i].layerStack) {  
  42.                         disp->setLayerStack(state.layerStack);  
  43.                     }  
  44.                     //如果两个对象的方向、viewport、frame不相等，使用当前对象的  
  45.                     if ((state.orientation != draw[i].orientation)  
  46.                             || (state.viewport != draw[i].viewport)  
  47.                             || (state.frame != draw[i].frame))  
  48.                     {  
  49.                         disp->setProjection(state.orientation,  
  50.                                 state.viewport, state.frame);  
  51.                     }  
  52.                     if (state.width != draw[i].width || state.height != draw[i].height) {  
  53.                         disp->setDisplaySize(state.width, state.height);  
  54.                     }  
  55.                 }  
  56.             }  
  57.         }  
  58.   
  59.         // 处理显示设备增加的情况  
  60.         for (size_t i=0 ; i<cc ; i++) {  
  61.             if (draw.indexOfKey(curr.keyAt(i)) < 0) {  
  62.             //当前列表中某个设备在以前列表中没有找到，说明是增加的设备  
  63.             //创建DisplayDevice对象，把它加入到mDisplays列表中  
  64.                 ......  
  65.                 const wp<IBinder>& display(curr.keyAt(i));  
  66.                 if (dispSurface != NULL) {  
  67.                     sp<DisplayDevice> hw = new DisplayDevice(this,  
  68.                             state.type, hwcDisplayId,  
  69.                             mHwc->getFormat(hwcDisplayId), state.isSecure,  
  70.                             display, dispSurface, producer,  
  71.                             mRenderEngine->getEGLConfig());  
  72.                     ......  
  73.                     mDisplays.add(display, hw);  
  74.                     ......  
  75.                 }  
  76.             }  
  77.         }  
  78.     }  
  79. }  

这段代码的作用是处理显示设备的变化，分成3种情况：

1.显示设备减少了，需要把显示设备对应的DisplayDevice移除

2.显示设备发生了变化，例如用户设置了Surface、重新设置了layerStack、旋转了屏幕等，这就需要重新设置显示对象的属性

3.显示设备增加了，创建新的DisplayDevice加入系统中。

这些在之前博客都分析过，我们主要看下几个变量mCurrentState.displays， mDrawingState.displays。代表之前的设备和现在的设备。

这些displays是State的一个变量，是每个display的一个唯一码对应一个DisplayDeviceState（状态）。

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. struct State {  
  2.     LayerVector layersSortedByZ;  
  3.     DefaultKeyedVector< wp<IBinder>, DisplayDeviceState> displays;  
  4. };  

而mDisplays是一个Display的唯一码 对应一个DisplayDevice。

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. DefaultKeyedVector< wp<IBinder>, sp<DisplayDevice> > mDisplays;  

而这里主要用mCurrentState.displays， mDrawingState.displays中的Display的唯一码看哪个DisplayDevice增加了或者删除了，再去根据这个唯一码来对应在mDisplays中的DisplayDevice增加或者删除或者一些状态的修改。


1.3 设置TransformHint

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. if (transactionFlags & (eTraversalNeeded|eDisplayTransactionNeeded)) {  
  2.     sp<const DisplayDevice> disp;  
  3.     uint32_t currentlayerStack = 0;  
  4.     for (size_t i=0; i<count; i++) {  
  5.         // NOTE: we rely on the fact that layers are sorted by  
  6.         // layerStack first (so we don't have to traverse the list  
  7.         // of displays for every layer).  
  8.         const sp<Layer>& layer(currentLayers[i]);  
  9.         uint32_t layerStack = layer->getDrawingState().layerStack;  
  10.         if (i==0 || currentlayerStack != layerStack) {  
  11.             currentlayerStack = layerStack;  
  12.             // figure out if this layerstack is mirrored  
  13.             // (more than one display) if so, pick the default display,  
  14.             // if not, pick the only display it's on.  
  15.             disp.clear();//清除disp  
  16.             for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {  
  17.                 sp<const DisplayDevice> hw(mDisplays[dpy]);  
  18.                 if (hw->getLayerStack() == currentlayerStack) {  
  19.                     if (disp == NULL) {  
  20.                         disp = hw;//找到了一个layerStacker相同的显示设备  
  21.                     } else {  
  22.                         disp = NULL;//如果有两个显示设备的layerStacker相同，都不用  
  23.                         break;  
  24.                     }  
  25.                 }  
  26.             }  
  27.         }  
  28.         if (disp == NULL) {  
  29.             // 没有找到具有相同layerStack的显示设备，使用缺省设备  
  30.             disp = getDefaultDisplayDevice();  
  31.         }  
  32.         layer->updateTransformHint(disp);//设置Layer对象的TransformHint  
  33.     }  
  34. }  

这段代码的作用是根据每种显示设备的不同，设置和显示设备关联在一起的Layer（主要看Layer的layerStack是否和DisplayDevice的layerStack）的TransformHint（主要指设备的显示方向orientation）。



1.4 处理Layer增加情况

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. const LayerVector& layers(mDrawingState.layersSortedByZ);  
  2. if (currentLayers.size() > layers.size()) {  
  3.     // 如果有Layer加入，设置需要更新  
  4.     mVisibleRegionsDirty = true;  
  5. }  
  6.   
  7. // 处理有Layer删除的情况  
  8. if (mLayersRemoved) {  
  9.     mLayersRemoved = false;  
  10.     mVisibleRegionsDirty = true;  
  11.     const size_t count = layers.size();  
  12.     for (size_t i=0 ; i<count ; i++) {  
  13.         const sp<Layer>& layer(layers[i]);  
  14.         if (currentLayers.indexOf(layer) < 0) {  
  15.             //如果这个Layer已经不存在了，把它的所在区域设置为需要更新的区域  
  16.             const Layer::State& s(layer->getDrawingState());  
  17.             Region visibleReg = s.transform.transform(  
  18.                     Region(Rect(s.active.w, s.active.h)));  
  19.             invalidateLayerStack(s.layerStack, visibleReg);  
  20.         }  
  21.     }  
  22. }  

这段代码处理Layer的增加情况，如果Layer增加了，需要重新计算设备的更新区域，因此把mVisibleRegionsDirty设为true，如果Layer删除了，需要把Layer的可见区域加入到系统需要更新的区域中。

而这里mVisibleRegionsDirty设为true代表Layer需要更新，如果Layer不需要更新的话后面的rebuildLayerStack函数的执行就是空的了。


1.5 设置mDrawingState

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. commitTransaction();    
  2.     
  3. updateCursorAsync();    
调用commitTransaction和updateCursorAsync函数 commitTransaction函数作用是把mDrawingState的值设置成mCurrentState的值。而updateCursorAsync函数会更新所有显示设备中光标的位置。

1.6 小结

handleTransaction函数的作用的就是处理系统在两次刷新期间的各种变化。SurfaceFlinger模块中不管是SurfaceFlinger类还是Layer类，都采用了双缓冲的方式来保存他们的属性，这样的好处是刚改变SurfaceFlinger对象或者Layer类对象的属性是，不需要上锁，大大的提高了系统效率。只有在最后的图像输出是，才进行一次上锁，并进行内存的属性变化处理。正因此，应用进程必须收到VSync信号才开始改变Surface的内容。


二、handlePageFlip函数

代码如下，这个函数就是更新Layer中的buffer（内容），遍历每个Layer看这个Layer是否有内容更新，就看其hasQueuedFrame函数是否返回true。之前分析过当有更新的话，mQueuedFrames的值会加1.而hasQueuedFrame函数就是看这个值是否为0

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. bool SurfaceFlinger::handlePageFlip()  
  2. {  
  3.     Region dirtyRegion;  
  4.   
  5.     bool visibleRegions = false;  
  6.     const LayerVector& layers(mDrawingState.layersSortedByZ);  
  7.     bool frameQueued = false;  
  8.   
  9.     Vector<Layer*> layersWithQueuedFrames;  
  10.     //查找需要更新的Layer  
  11.     for (size_t i = 0, count = layers.size(); i<count ; i++) {  
  12.         const sp<Layer>& layer(layers[i]);  
  13.         if (layer->hasQueuedFrame()) {  
  14.             frameQueued = true;  
  15.             if (layer->shouldPresentNow(mPrimaryDispSync)) {  
  16.                 layersWithQueuedFrames.push_back(layer.get());  
  17.             } else {  
  18.                 layer->useEmptyDamage();  
  19.             }  
  20.         } else {  
  21.             layer->useEmptyDamage();  
  22.         }  
  23.     }  
  24.     for (size_t i = 0, count = layersWithQueuedFrames.size() ; i<count ; i++) {  
  25.         Layer* layer = layersWithQueuedFrames[i];  
  26.         const Region dirty(layer->latchBuffer(visibleRegions));  
  27.         layer->useSurfaceDamage();  
  28.         const Layer::State& s(layer->getDrawingState());  
  29.         invalidateLayerStack(s.layerStack, dirty);  
  30.     }  
  31.   
  32.     mVisibleRegionsDirty |= visibleRegions;  
  33.   
  34.     if (frameQueued && layersWithQueuedFrames.empty()) {  
  35.         signalLayerUpdate();  
  36.     }  
  37.   
  38.     return !layersWithQueuedFrames.empty();  
  39. }  

hasQueuedFrame函数如下。

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. bool hasQueuedFrame() const { return mQueuedFrames > 0 || mSidebandStreamChanged; }  
最后把所有需要更新的Layer放在layersWithQueuedFrames，然后调用每个Layer的latchBuffer函数。

调用每个Layer的latchBuffer函数根据返回的更新区域调用invalidateLayerStack来设置更新设备对象的更新区域。

我们先来看看invalidateLayerStack函数，在SurfaceFlinger.cpp中的invalidateLayerStack。先是遍历所有的设备，找到和Layer的layerStack一样的设备，然后调用了DisplayDevice的dirtyRegion.orSelf方法

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. void SurfaceFlinger::invalidateLayerStack(uint32_t layerStack,  
  2.         const Region& dirty) {  
  3.     for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {  
  4.         const sp<DisplayDevice>& hw(mDisplays[dpy]);  
  5.         if (hw->getLayerStack() == layerStack) {  
  6.             hw->dirtyRegion.orSelf(dirty);  
  7.         }  
  8.     }  
  9. }  
orSelf方法，就是把Layer的更新区域 加到 DisplayDevice的dirtyRegion区域上。
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. Region& Region::orSelf(const Rect& r) {  
  2.     return operationSelf(r, op_or);  
  3. }  

最后我们再来看看latchBuffer函数
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. Region Layer::latchBuffer(bool& recomputeVisibleRegions)  
  2. {  
  3.     ATRACE_CALL();  
  4.   
  5.     if (android_atomic_acquire_cas(true, false, &mSidebandStreamChanged) == 0) {  
  6.         // mSidebandStreamChanged was true  
  7.         mSidebandStream = mSurfaceFlingerConsumer->getSidebandStream();  
  8.         if (mSidebandStream != NULL) {  
  9.             setTransactionFlags(eTransactionNeeded);  
  10.             mFlinger->setTransactionFlags(eTraversalNeeded);  
  11.         }  
  12.         recomputeVisibleRegions = true;  
  13.   
  14.         const State& s(getDrawingState());  
  15.         return s.transform.transform(Region(Rect(s.active.w, s.active.h)));  
  16.     }  
  17.   
  18.     Region outDirtyRegion;  
  19.     if (mQueuedFrames > 0) { //mQueuedFrames大于0代表有Surface更新的要求  
  20.         if (mRefreshPending) {  
  21.             return outDirtyRegion;  
  22.         }  
  23.   
  24.         // Capture the old state of the layer for comparisons later  
  25.         const State& s(getDrawingState());//注意这是使用的DrawingState  
  26.         const bool oldOpacity = isOpaque(s);  
  27.         sp<GraphicBuffer> oldActiveBuffer = mActiveBuffer;  
  28.   
  29.         struct Reject : public SurfaceFlingerConsumer::BufferRejecter {  
  30.             ......//定义Reject结构体  
  31.         };  
  32.   
  33.         Reject r(mDrawingState, getCurrentState(), recomputeVisibleRegions,  
  34.                 getProducerStickyTransform() != 0);  
  35.   
  36.         uint64_t maxFrameNumber = 0;  
  37.         {  
  38.             Mutex::Autolock lock(mQueueItemLock);  
  39.             maxFrameNumber = mLastFrameNumberReceived;  
  40.         }  
  41.   
  42.         status_t updateResult = mSurfaceFlingerConsumer->updateTexImage(&r,//更新纹理  
  43.                 mFlinger->mPrimaryDispSync, maxFrameNumber);  
  44.         if (updateResult == BufferQueue::PRESENT_LATER) {  
  45.             mFlinger->signalLayerUpdate();//如果结果是推迟处理，发送Invalidate消息  
  46.             return outDirtyRegion;  
  47.         } else if (updateResult == SurfaceFlingerConsumer::BUFFER_REJECTED) {  
  48.             // If the buffer has been rejected, remove it from the shadow queue  
  49.             // and return early  
  50.             Mutex::Autolock lock(mQueueItemLock);  
  51.             mQueueItems.removeAt(0);  
  52.             android_atomic_dec(&mQueuedFrames);  
  53.             return outDirtyRegion;  
  54.         } else if (updateResult != NO_ERROR || mUpdateTexImageFailed) {  
  55.             // This can occur if something goes wrong when trying to create the  
  56.             // EGLImage for this buffer. If this happens, the buffer has already  
  57.             // been released, so we need to clean up the queue and bug out  
  58.             // early.  
  59.             {  
  60.                 Mutex::Autolock lock(mQueueItemLock);  
  61.                 mQueueItems.clear();  
  62.                 android_atomic_and(0, &mQueuedFrames);  
  63.             }  
  64.   
  65.             // Once we have hit this state, the shadow queue may no longer  
  66.             // correctly reflect the incoming BufferQueue's contents, so even if  
  67.             // updateTexImage starts working, the only safe course of action is  
  68.             // to continue to ignore updates.  
  69.             mUpdateTexImageFailed = true;  
  70.   
  71.             return outDirtyRegion;  
  72.         }  
  73.   
  74.         { // Autolock scope  
  75.             auto currentFrameNumber = mSurfaceFlingerConsumer->getFrameNumber();  
  76.   
  77.             Mutex::Autolock lock(mQueueItemLock);  
  78.   
  79.             // Remove any stale buffers that have been dropped during  
  80.             // updateTexImage  
  81.             while (mQueueItems[0].mFrameNumber != currentFrameNumber) {  
  82.                 mQueueItems.removeAt(0);  
  83.                 android_atomic_dec(&mQueuedFrames);  
  84.             }  
  85.   
  86.             mQueueItems.removeAt(0);  
  87.         }  
  88.   
  89.   
  90.         // Decrement the queued-frames count.  Signal another event if we  
  91.         // have more frames pending.  
  92.         if (android_atomic_dec(&mQueuedFrames) > 1) {//减少mQueuedFrames的值  
  93.             mFlinger->signalLayerUpdate();//如果还有更多frame需要处理，要发消息  
  94.         }  
  95.   
  96.         if (updateResult != NO_ERROR) {  
  97.             // something happened!  
  98.             recomputeVisibleRegions = true;  
  99.             return outDirtyRegion;  
  100.         }  
  101.   
  102.         //更新mActiveBuffer，得到现在需要输出的图像数据  
  103.         mActiveBuffer = mSurfaceFlingerConsumer->getCurrentBuffer();  
  104.         if (mActiveBuffer == NULL) {  
  105.             return outDirtyRegion;//出错  
  106.         }  
  107.   
  108.         mRefreshPending = true;  
  109.         mFrameLatencyNeeded = true;  
  110.         //下面根据各种情况是否重新计算更新区域  
  111.         if (oldActiveBuffer == NULL) {  
  112.              // the first time we receive a buffer, we need to trigger a  
  113.              // geometry invalidation.  
  114.             recomputeVisibleRegions = true;  
  115.          }  
  116.   
  117.         Rect crop(mSurfaceFlingerConsumer->getCurrentCrop());  
  118.         const uint32_t transform(mSurfaceFlingerConsumer->getCurrentTransform());  
  119.         const uint32_t scalingMode(mSurfaceFlingerConsumer->getCurrentScalingMode());  
  120.         if ((crop != mCurrentCrop) ||  
  121.             (transform != mCurrentTransform) ||  
  122.             (scalingMode != mCurrentScalingMode))  
  123.         {  
  124.             mCurrentCrop = crop;  
  125.             mCurrentTransform = transform;  
  126.             mCurrentScalingMode = scalingMode;  
  127.             recomputeVisibleRegions = true;  
  128.         }  
  129.   
  130.         if (oldActiveBuffer != NULL) {  
  131.             uint32_t bufWidth  = mActiveBuffer->getWidth();  
  132.             uint32_t bufHeight = mActiveBuffer->getHeight();  
  133.             if (bufWidth != uint32_t(oldActiveBuffer->width) ||  
  134.                 bufHeight != uint32_t(oldActiveBuffer->height)) {  
  135.                 recomputeVisibleRegions = true;  
  136.             }  
  137.         }  
  138.   
  139.         mCurrentOpacity = getOpacityForFormat(mActiveBuffer->format);  
  140.         if (oldOpacity != isOpaque(s)) {  
  141.             recomputeVisibleRegions = true;  
  142.         }  
  143.   
  144.         // FIXME: postedRegion should be dirty & bounds  
  145.         Region dirtyRegion(Rect(s.active.w, s.active.h));  
  146.   
  147.         // transform the dirty region to window-manager space  
  148.         outDirtyRegion = (s.transform.transform(dirtyRegion));//返回Layer的更新区域  
  149.     }  
  150.     return outDirtyRegion;  
  151. }  

这里我们来看mSurfaceFlingerConsumer->updateTexImage更新纹理

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. status_t SurfaceFlingerConsumer::updateTexImage(BufferRejecter* rejecter,  
  2.         const DispSync& dispSync, uint64_t maxFrameNumber)  
  3. {  
  4.     ATRACE_CALL();  
  5.     Mutex::Autolock lock(mMutex);  
  6.   
  7.     if (mAbandoned) {  
  8.         ALOGE("updateTexImage: GLConsumer is abandoned!");  
  9.         return NO_INIT;  
  10.     }  
  11.   
  12.     // Make sure the EGL state is the same as in previous calls.  
  13.     status_t err = checkAndUpdateEglStateLocked();  
  14.     if (err != NO_ERROR) {  
  15.         return err;  
  16.     }  
  17.   
  18.     BufferItem item;  
  19.   
  20.     // Acquire the next buffer.  
  21.     // In asynchronous mode the list is guaranteed to be one buffer  
  22.     // deep, while in synchronous mode we use the oldest buffer.  
  23.     err = acquireBufferLocked(&item, computeExpectedPresent(dispSync),//消费者端取数据  
  24.             maxFrameNumber);  
  25.     if (err != NO_ERROR) {  
  26.         if (err == BufferQueue::NO_BUFFER_AVAILABLE) {  
  27.             err = NO_ERROR;  
  28.         } else if (err == BufferQueue::PRESENT_LATER) {  
  29.             // return the error, without logging  
  30.         } else {  
  31.             ALOGE("updateTexImage: acquire failed: %s (%d)",  
  32.                 strerror(-err), err);  
  33.         }  
  34.         return err;  
  35.     }  
  36.   
  37.   
  38.     // We call the rejecter here, in case the caller has a reason to  
  39.     // not accept this buffer.  This is used by SurfaceFlinger to  
  40.     // reject buffers which have the wrong size  
  41.     int buf = item.mBuf;  
  42.     if (rejecter && rejecter->reject(mSlots[buf].mGraphicBuffer, item)) {  
  43.         releaseBufferLocked(buf, mSlots[buf].mGraphicBuffer, EGL_NO_SYNC_KHR);  
  44.         return BUFFER_REJECTED;  
  45.     }  
  46.   
  47.     // Release the previous buffer.  
  48.     err = updateAndReleaseLocked(item);  
  49.     if (err != NO_ERROR) {  
  50.         return err;  
  51.     }  
  52.   
  53.     if (!SyncFeatures::getInstance().useNativeFenceSync()) {  
  54.         // Bind the new buffer to the GL texture.  
  55.         //  
  56.         // Older devices require the "implicit" synchronization provided  
  57.         // by glEGLImageTargetTexture2DOES, which this method calls.  Newer  
  58.         // devices will either call this in Layer::onDraw, or (if it's not  
  59.         // a GL-composited layer) not at all.  
  60.         err = bindTextureImageLocked();  
  61.     }  
  62.   
  63.     return err;  
  64. }  
我们再来看看updateAndReleaseLocked函数,这个函数释放了buffer，然后更新了mCurrentTexture mCurrentTextureImage等。
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. status_t GLConsumer::updateAndReleaseLocked(const BufferItem& item)  
  2. {  
  3.     status_t err = NO_ERROR;  
  4.   
  5.     int buf = item.mBuf;  
  6.   
  7.     if (!mAttached) {  
  8.         releaseBufferLocked(buf, mSlots[buf].mGraphicBuffer,  
  9.                 mEglDisplay, EGL_NO_SYNC_KHR);  
  10.         return INVALID_OPERATION;  
  11.     }  
  12.   
  13.     err = checkAndUpdateEglStateLocked();  
  14.     ......  
  15.     err = mEglSlots[buf].mEglImage->createIfNeeded(mEglDisplay, item.mCrop);  
  16.     ......  
  17.     err = syncForReleaseLocked(mEglDisplay);  
  18.     ......  
  19.   
  20.     //释放buffer  
  21.     if (mCurrentTexture != BufferQueue::INVALID_BUFFER_SLOT) {  
  22.         status_t status = releaseBufferLocked(  
  23.                 mCurrentTexture, mCurrentTextureImage->graphicBuffer(),  
  24.                 mEglDisplay, mEglSlots[mCurrentTexture].mEglFence);  
  25.         if (status < NO_ERROR) {  
  26.             GLC_LOGE("updateAndRelease: failed to release buffer: %s (%d)",  
  27.                    strerror(-status), status);  
  28.             err = status;  
  29.             // keep going, with error raised [?]  
  30.         }  
  31.     }  
  32.   
  33.     // 更新状态  
  34.     mCurrentTexture = buf;  
  35.     mCurrentTextureImage = mEglSlots[buf].mEglImage;  
  36.     mCurrentCrop = item.mCrop;  
  37.     mCurrentTransform = item.mTransform;  
  38.     mCurrentScalingMode = item.mScalingMode;  
  39.     mCurrentTimestamp = item.mTimestamp;  
  40.     mCurrentFence = item.mFence;  
  41.     mCurrentFrameNumber = item.mFrameNumber;  
  42.   
  43.     computeCurrentTransformMatrixLocked();  
  44.   
  45.     return err;  
  46. }  
最后Layer的mActiveBuffer是从mSurfaceFlingerConsumer->getCurrentBuffer()，而就是mCurrentTextureImage变量。
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. sp<GraphicBuffer> GLConsumer::getCurrentBuffer() const {  
  2.     Mutex::Autolock lock(mMutex);  
  3.     return (mCurrentTextureImage == NULL) ?  
  4.             NULL : mCurrentTextureImage->graphicBuffer();  
  5. }  

LatchBuffer函数调用updateTextImage来得到需要的图像。这里参数r是Reject对象，其作用是判断在缓冲区的尺寸是否符合要求。调用updateTextImage函数如果得到的结果是PRESENT_LATER,表示推迟处理，然后调用signalLayerUpdate函数来发送invalidate消息，这次绘制过程就不处理这个Surface的图像了。

如果不需要推迟处理，把mQueuedFrames的值减1.

最后LatchBuffer函数调用mSurfaceFlingerConsumer的getCurrentBuffer来取回当前的图像缓冲区指针，保存在mActiveBuffer中。



这样经过handleTransaction handlePageFlip两个函数处理，SurfaceFlinger中无论是Layer属性的变化还是图像的变化都处理好了，只等VSync信号到来就可以输出了。



三、rebuildLayerStack函数

VSync信号来了之后先是调用的这个函数，前面分析handleTransactionLocked的时候，当mVisibleRegionsDirty为 true代表是要更新Layer，这里上来就是看这个变量是否为true。

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. void SurfaceFlinger::rebuildLayerStacks() {  
  2.     // rebuild the visible layer list per screen  
  3.     if (CC_UNLIKELY(mVisibleRegionsDirty)) {//mVisibleRegionsDirty是否为true  
  4.         ATRACE_CALL();  
  5.         mVisibleRegionsDirty = false;  
  6.         invalidateHwcGeometry();  
  7.           
  8.         //计算每个显示设备上可见的Layer  
  9.         const LayerVector& layers(mDrawingState.layersSortedByZ);  
  10.         for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {  
  11.             Region opaqueRegion;  
  12.             Region dirtyRegion;  
  13.             Vector< sp<Layer> > layersSortedByZ;  
  14.             const sp<DisplayDevice>& hw(mDisplays[dpy]);  
  15.             const Transform& tr(hw->getTransform());  
  16.             const Rect bounds(hw->getBounds());  
  17.             if (hw->isDisplayOn()) {  
  18.                 //计算每个layer的可见区域，确定设备需要重新绘制的区域  
  19.                 SurfaceFlinger::computeVisibleRegions(layers,  
  20.                         hw->getLayerStack(), dirtyRegion, opaqueRegion);  
  21.   
  22.                 const size_t count = layers.size();  
  23.                 for (size_t i=0 ; i<count ; i++) {  
  24.                     const sp<Layer>& layer(layers[i]);  
  25.                     const Layer::State& s(layer->getDrawingState());  
  26.                     if (s.layerStack == hw->getLayerStack()) {  
  27.                         //只需要和显示设备的LayerStack相同的layer  
  28.                         Region drawRegion(tr.transform(  
  29.                                 layer->visibleNonTransparentRegion));  
  30.                         drawRegion.andSelf(bounds);  
  31.                         if (!drawRegion.isEmpty()) {  
  32.                             //如果Layer的显示区域和显示设备的窗口有交集  
  33.                             //把Layer加入列表中  
  34.                             layersSortedByZ.add(layer);  
  35.                         }  
  36.                     }  
  37.                 }  
  38.             }  
  39.             //设置显示设备的可见Layer列表  
  40.             hw->setVisibleLayersSortedByZ(layersSortedByZ);  
  41.             hw->undefinedRegion.set(bounds);  
  42.             hw->undefinedRegion.subtractSelf(tr.transform(opaqueRegion));  
  43.             hw->dirtyRegion.orSelf(dirtyRegion);//设置每个DisplayDevice的drawRegions 加上dirtyRegion区域  
  44.         }  
  45.     }  
  46. }  

rebuildLayerStacks函数的作用是重建每个显示设备的可见layer对象列表。其他的说明还是看另一篇博客http://write.blog.csdn.net/postedit?ref=toolbar&ticket=ST-83533-ejxpwYJbCoASdBlu6Tpr-passport.csdn.net


四、setUpHWComposer函数

HWComposer中有一个类型为DisplayData结构的数组mDisplayData[]，维护每个显示设备的信息。我们先来看在HWComposer构造函数中有下面这段代码，我们这里mFbDev为空，因此我们遍历每个设备，调用queryDisplayProperties函数。

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. if (mFbDev) {  
  2.     ALOGD("chenchen mFbDev end");  
  3.     ALOG_ASSERT(!(mHwc && hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)),  
  4.             "should only have fbdev if no hwc or hwc is 1.0");  
  5.   
  6.     DisplayData& disp(mDisplayData[HWC_DISPLAY_PRIMARY]);  
  7.     disp.connected = true;  
  8.     disp.format = mFbDev->format;  
  9.     DisplayConfig config = DisplayConfig();  
  10.     config.width = mFbDev->width;  
  11.     config.height = mFbDev->height;  
  12.     config.xdpi = mFbDev->xdpi;  
  13.     config.ydpi = mFbDev->ydpi;  
  14.     config.refresh = nsecs_t(1e9 / mFbDev->fps);  
  15.     disp.configs.push_back(config);  
  16.     disp.currentConfig = 0;  
  17. } else if (mHwc) {  
  18.     // here we're guaranteed to have at least HWC 1.1  
  19.     for (size_t i =0 ; i<NUM_BUILTIN_DISPLAYS ; i++) {  
  20.         queryDisplayProperties(i);  
  21.     }  
  22. }  

下面我们来看queryDisplayProperties函数，通过hwc模块的getDisplayConfigs和getDisplayAttributes方法来获取configs，最后把格式和connect设置为true。

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. status_t HWComposer::queryDisplayProperties(int disp) {  
  2.   
  3.     LOG_ALWAYS_FATAL_IF(!mHwc || !hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1));  
  4.   
  5.     // use zero as default value for unspecified attributes  
  6.     int32_t values[NUM_DISPLAY_ATTRIBUTES - 1];  
  7.     memset(values, 0, sizeof(values));  
  8.   
  9.     const size_t MAX_NUM_CONFIGS = 128;  
  10.     uint32_t configs[MAX_NUM_CONFIGS] = {0};  
  11.     size_t numConfigs = MAX_NUM_CONFIGS;  
  12.     status_t err = mHwc->getDisplayConfigs(mHwc, disp, configs, &numConfigs);  
  13.     if (err != NO_ERROR) {  
  14.         // this can happen if an unpluggable display is not connected  
  15.         mDisplayData[disp].connected = false;  
  16.         return err;  
  17.     }  
  18.   
  19.     mDisplayData[disp].currentConfig = 0;  
  20.     for (size_t c = 0; c < numConfigs; ++c) {  
  21.         err = mHwc->getDisplayAttributes(mHwc, disp, configs[c],  
  22.                 DISPLAY_ATTRIBUTES, values);  
  23.         // If this is a pre-1.5 HWC, it may not know about color transform, so  
  24.         // try again with a smaller set of attributes  
  25.         if (err != NO_ERROR) {  
  26.             err = mHwc->getDisplayAttributes(mHwc, disp, configs[c],  
  27.                     PRE_HWC15_DISPLAY_ATTRIBUTES, values);  
  28.         }  
  29.         if (err != NO_ERROR) {  
  30.             // we can't get this display's info. turn it off.  
  31.             mDisplayData[disp].connected = false;  
  32.             return err;  
  33.         }  
  34.   
  35.         DisplayConfig config = DisplayConfig();  
  36.         for (size_t i = 0; i < NUM_DISPLAY_ATTRIBUTES - 1; i++) {  
  37.             switch (DISPLAY_ATTRIBUTES[i]) {  
  38.                 case HWC_DISPLAY_VSYNC_PERIOD:  
  39.                     config.refresh = nsecs_t(values[i]);//设置config  
  40.                     break;  
  41.                 case HWC_DISPLAY_WIDTH:  
  42.                     config.width = values[i];  
  43.                     break;  
  44.                 case HWC_DISPLAY_HEIGHT:  
  45.                     config.height = values[i];  
  46.                     break;  
  47.                 case HWC_DISPLAY_DPI_X:  
  48.                     config.xdpi = values[i] / 1000.0f;  
  49.                     break;  
  50.                 case HWC_DISPLAY_DPI_Y:  
  51.                     config.ydpi = values[i] / 1000.0f;  
  52.                     break;  
  53.                 case HWC_DISPLAY_COLOR_TRANSFORM:  
  54.                     config.colorTransform = values[i];  
  55.                     break;  
  56.                 default:  
  57.                     ALOG_ASSERT(false, "unknown display attribute[%zu] %#x",  
  58.                             i, DISPLAY_ATTRIBUTES[i]);  
  59.                     break;  
  60.             }  
  61.         }  
  62.   
  63.         if (config.xdpi == 0.0f || config.ydpi == 0.0f) {  
  64.             float dpi = getDefaultDensity(config.width, config.height);  
  65.             config.xdpi = dpi;  
  66.             config.ydpi = dpi;  
  67.         }  
  68.   
  69.         mDisplayData[disp].configs.push_back(config);  
  70.     }  
  71.   
  72.     // FIXME: what should we set the format to?  
  73.     mDisplayData[disp].format = HAL_PIXEL_FORMAT_RGBA_8888;//格式  
  74.     mDisplayData[disp].connected = true;//已连接  
  75.     return NO_ERROR;  
  76. }  

我们再来看SurfaceFlinger中init函数，后面创建DisplayDevice过程。

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. for (size_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) {  
  2.     DisplayDevice::DisplayType type((DisplayDevice::DisplayType)i);  
  3.     // set-up the displays that are already connected  
  4.     if (mHwc->isConnected(i) || type==DisplayDevice::DISPLAY_PRIMARY) {//当前设备连接了，或者是默认设备（即使没有连接）  
  5.         // All non-virtual displays are currently considered secure.  
  6.         bool isSecure = true;  
  7.         createBuiltinDisplayLocked(type);//分配一个token  
  8.         wp<IBinder> token = mBuiltinDisplays[i];  
  9.   
  10.         sp<IGraphicBufferProducer> producer;  
  11.         sp<IGraphicBufferConsumer> consumer;  
  12.         BufferQueue::createBufferQueue(&producer, &consumer,//创建producer consumer  
  13.                 new GraphicBufferAlloc());  
  14.   
  15.         sp<FramebufferSurface> fbs = new FramebufferSurface(*mHwc, i,  
  16.                 consumer);  
  17.         int32_t hwcId = allocateHwcDisplayId(type);  
  18.         sp<DisplayDevice> hw = new DisplayDevice(this,//创建DisplayDevice  
  19.                 type, hwcId, mHwc->getFormat(hwcId), isSecure, token,  
  20.                 fbs, producer,  
  21.                 mRenderEngine->getEGLConfig());  
  22.         if (i > DisplayDevice::DISPLAY_PRIMARY) {  
  23.             // FIXME: currently we don't get blank/unblank requests  
  24.             // for displays other than the main display, so we always  
  25.             // assume a connected display is unblanked.  
  26.             ALOGD("marking display %zu as acquired/unblanked", i);  
  27.             hw->setPowerMode(HWC_POWER_MODE_NORMAL);  
  28.         }  
  29.         mDisplays.add(token, hw);//放入mDisplays中  
  30.     }  
  31. }  

setUpHWComposer函数的作用是更新HWComposer对象中图层对象列表以及图层属性。下面函数先会遍历各个设备DisplayDevice，然后根据可见layer数量，调用createWorkList创建hwc_layer_list_t列表，然后在每个设备上遍历可见layer，将layer的mActiveBuffer设置到HWComposer中去，最后调用了HWComposer的prepare函数。

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. void SurfaceFlinger::setUpHWComposer() {  
  2.     ......  
  3.     HWComposer& hwc(getHwComposer());  
  4.     if (hwc.initCheck() == NO_ERROR) {  
  5.         // build the h/w work list  
  6.         if (CC_UNLIKELY(mHwWorkListDirty)) {  
  7.             mHwWorkListDirty = false;  
  8.             for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {//遍历mDisplays  
  9.                 sp<const DisplayDevice> hw(mDisplays[dpy]);  
  10.                 const int32_t id = hw->getHwcDisplayId();  
  11.                 if (id >= 0) {  
  12.                     const Vector< sp<Layer> >& currentLayers(//遍历DisplayDevice所有可见layer  
  13.                         hw->getVisibleLayersSortedByZ());  
  14.                     const size_t count = currentLayers.size();  
  15.                     if (hwc.createWorkList(id, count) == NO_ERROR) {//根据layer数量调用createWorkList创建hwc_layer_list_t列表  
  16.                         HWComposer::LayerListIterator cur = hwc.begin(id);  
  17.                         const HWComposer::LayerListIterator end = hwc.end(id);  
  18.                         for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {  
  19.                             const sp<Layer>& layer(currentLayers[i]);  
  20.                             layer->setGeometry(hw, *cur);  
  21.                             if (mDebugDisableHWC || mDebugRegion || mDaltonize || mHasColorMatrix) {  
  22.                                 cur->setSkip(true);  
  23.                             }  
  24.                         }  
  25.                     }  
  26.                 }  
  27.             }  
  28.         }  
  29.   
  30.         // set the per-frame data  
  31.         for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {  
  32.             sp<const DisplayDevice> hw(mDisplays[dpy]);  
  33.             const int32_t id = hw->getHwcDisplayId();  
  34.             if (id >= 0) {  
  35.                 const Vector< sp<Layer> >& currentLayers(  
  36.                     hw->getVisibleLayersSortedByZ());  
  37.                 const size_t count = currentLayers.size();  
  38.                 HWComposer::LayerListIterator cur = hwc.begin(id);  
  39.                 const HWComposer::LayerListIterator end = hwc.end(id);  
  40.                 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {  
  41.                     //将layer的mActiveBuffer设置到HWComposer中去  
  42.                     const sp<Layer>& layer(currentLayers[i]);  
  43.                     layer->setPerFrameData(hw, *cur);  
  44.                 }  
  45.             }  
  46.         }  
  47.   
  48.         // If possible, attempt to use the cursor overlay on each display.  
  49.         for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {  
  50.             sp<const DisplayDevice> hw(mDisplays[dpy]);  
  51.             const int32_t id = hw->getHwcDisplayId();  
  52.             if (id >= 0) {  
  53.                 const Vector< sp<Layer> >& currentLayers(  
  54.                     hw->getVisibleLayersSortedByZ());  
  55.                 const size_t count = currentLayers.size();  
  56.                 HWComposer::LayerListIterator cur = hwc.begin(id);  
  57.                 const HWComposer::LayerListIterator end = hwc.end(id);  
  58.                 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {  
  59.                     const sp<Layer>& layer(currentLayers[i]);  
  60.                     if (layer->isPotentialCursor()) {  
  61.                         cur->setIsCursorLayerHint();  
  62.                         break;  
  63.                     }  
  64.                 }  
  65.             }  
  66.         }  
  67.   
  68.         status_t err = hwc.prepare();  
  69.         ALOGE_IF(err, "HWComposer::prepare failed (%s)", strerror(-err));  
  70.   
  71.         for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {  
  72.             sp<const DisplayDevice> hw(mDisplays[dpy]);  
  73.             hw->prepareFrame(hwc);  
  74.         }  
  75.     }  
  76. }  
我们先来看下createWorkList函数，我们先为DisplayData的list申请内存，这个内存要先hwc_display_contents_1_t结构体本身的长度加上后面hwc_layer_1_t个数的长度。后面用DisplayData中list中hwLayers最后一个作为DisplayData中的framebufferTarget。注意到这个细节没有，当支持egl合成的时候，会把numLayers加1，这是因为如果支持egl合成list最后一个layer是egl合成后的buffer用的，所以要增加一个layer，而前面都是普通的layer。
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. status_t HWComposer::createWorkList(int32_t id, size_t numLayers) {  
  2.     if (uint32_t(id)>31 || !mAllocatedDisplayIDs.hasBit(id)) {  
  3.         return BAD_INDEX;  
  4.     }  
  5.   
  6.     if (mHwc) {  
  7.         DisplayData& disp(mDisplayData[id]);  
  8.         if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {  
  9.             // we need space for the HWC_FRAMEBUFFER_TARGET  
  10.             numLayers++;//注意到这个细节没有，当支持egl合成的时候，会把numLayers加1  
  11.         }  
  12.         if (disp.capacity < numLayers || disp.list == NULL) {//当DisplayData中的list为空，我们就要malloc  
  13.             size_t size = sizeof(hwc_display_contents_1_t)  
  14.                     + numLayers * sizeof(hwc_layer_1_t);//整个申请内存长度，hwc_display_contents_1_t结构体本身的长度加上后面hwc_layer_1_t个数的长度  
  15.             free(disp.list);  
  16.             disp.list = (hwc_display_contents_1_t*)malloc(size);//malloc  
  17.             disp.capacity = numLayers;  
  18.         }  
  19.         if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {  
  20.             disp.framebufferTarget = &disp.list->hwLayers[numLayers - 1];  
  21.             memset(disp.framebufferTarget, 0, sizeof(hwc_layer_1_t));//DisplayData的framebufferTarget清0  
  22.             const DisplayConfig& currentConfig =  
  23.                     disp.configs[disp.currentConfig];  
  24.             const hwc_rect_t r = { 0, 0,  
  25.                     (int) currentConfig.width, (int) currentConfig.height };  
  26.             disp.framebufferTarget->compositionType = HWC_FRAMEBUFFER_TARGET;  
  27.             disp.framebufferTarget->hints = 0;  
  28.             disp.framebufferTarget->flags = 0;  
  29.             disp.framebufferTarget->handle = disp.fbTargetHandle;  
  30.             disp.framebufferTarget->transform = 0;  
  31.             disp.framebufferTarget->blending = HWC_BLENDING_PREMULT;  
  32.             if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_3)) {  
  33.                 disp.framebufferTarget->sourceCropf.left = 0;  
  34.                 disp.framebufferTarget->sourceCropf.top = 0;  
  35.                 disp.framebufferTarget->sourceCropf.right =  
  36.                         currentConfig.width;  
  37.                 disp.framebufferTarget->sourceCropf.bottom =  
  38.                         currentConfig.height;  
  39.             } else {  
  40.                 disp.framebufferTarget->sourceCrop = r;  
  41.             }  
  42.             disp.framebufferTarget->displayFrame = r;  
  43.             disp.framebufferTarget->visibleRegionScreen.numRects = 1;  
  44.             disp.framebufferTarget->visibleRegionScreen.rects =  
  45.                 &disp.framebufferTarget->displayFrame;  
  46.             disp.framebufferTarget->acquireFenceFd = -1;  
  47.             disp.framebufferTarget->releaseFenceFd = -1;  
  48.             disp.framebufferTarget->planeAlpha = 0xFF;  
  49.         }  
  50.         disp.list->retireFenceFd = -1;  
  51.         disp.list->flags = HWC_GEOMETRY_CHANGED;  
  52.         disp.list->numHwLayers = numLayers;//DisplayData中list中layer的个数  
  53.     }  
  54.     return NO_ERROR;  
  55. }  

下面我们来看下DisplayData的数据结构

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. struct DisplayData {  
  2.     DisplayData();  
  3.     ~DisplayData();  
  4.     Vector<DisplayConfig> configs;  
  5.     size_t currentConfig;  
  6.     uint32_t format;    // pixel format from FB hal, for pre-hwc-1.1  
  7.     bool connected;  
  8.     bool hasFbComp;  
  9.     bool hasOvComp;  
  10.     size_t capacity;  
  11.     hwc_display_contents_1* list;  
  12.     hwc_layer_1* framebufferTarget;  
  13.     buffer_handle_t fbTargetHandle;  
  14.     sp<Fence> lastRetireFence;  // signals when the last set op retires  
  15.     sp<Fence> lastDisplayFence; // signals when the last set op takes  
  16.                                 // effect on screen  
  17.     buffer_handle_t outbufHandle;  
  18.     sp<Fence> outbufAcquireFence;  
  19.   
  20.     // protected by mEventControlLock  
  21.     int32_t events;  
  22. };  

再来看下hwc_display_contents_1。保留了原始的注释，我们先看hwc_display_contents_1，我们先看联合体union，第一个hwc_display_t dpy hwc_surface_t sur这个是EGL使用的，而如果是普通的就使用另外一个联合体outbuf什么的，后面还保存了layer的个数和hwc_layer_1_t 数组的起始地址hwLayers[0]

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. typedef struct hwc_display_contents_1 {  
  2.     /* File descriptor referring to a Sync HAL fence object which will signal 
  3.      * when this composition is retired. For a physical display, a composition 
  4.      * is retired when it has been replaced on-screen by a subsequent set. For 
  5.      * a virtual display, the composition is retired when the writes to 
  6.      * outputBuffer are complete and can be read. The fence object is created 
  7.      * and returned by the set call; this field will be -1 on entry to prepare 
  8.      * and set. SurfaceFlinger will close the returned file descriptor. 
  9.      */  
  10.     int retireFenceFd;  
  11.   
  12.     union {  
  13.         /* Fields only relevant for HWC_DEVICE_VERSION_1_0. */  
  14.         struct {  
  15.             /* (dpy, sur) is the target of SurfaceFlinger's OpenGL ES 
  16.              * composition for HWC_DEVICE_VERSION_1_0. They aren't relevant to 
  17.              * prepare. The set call should commit this surface atomically to 
  18.              * the display along with any overlay layers. 
  19.              */  
  20.             hwc_display_t dpy;  
  21.             hwc_surface_t sur;  
  22.         };  
  23.   
  24.         /* These fields are used for virtual displays when the h/w composer 
  25.          * version is at least HWC_DEVICE_VERSION_1_3. */  
  26.         struct {  
  27.             /* outbuf is the buffer that receives the composed image for 
  28.              * virtual displays. Writes to the outbuf must wait until 
  29.              * outbufAcquireFenceFd signals. A fence that will signal when 
  30.              * writes to outbuf are complete should be returned in 
  31.              * retireFenceFd. 
  32.              * 
  33.              * This field is set before prepare(), so properties of the buffer 
  34.              * can be used to decide which layers can be handled by h/w 
  35.              * composer. 
  36.              * 
  37.              * If prepare() sets all layers to FRAMEBUFFER, then GLES 
  38.              * composition will happen directly to the output buffer. In this 
  39.              * case, both outbuf and the FRAMEBUFFER_TARGET layer's buffer will 
  40.              * be the same, and set() has no work to do besides managing fences. 
  41.              * 
  42.              * If the TARGET_FORCE_HWC_FOR_VIRTUAL_DISPLAYS board config 
  43.              * variable is defined (not the default), then this behavior is 
  44.              * changed: if all layers are marked for FRAMEBUFFER, GLES 
  45.              * composition will take place to a scratch framebuffer, and 
  46.              * h/w composer must copy it to the output buffer. This allows the 
  47.              * h/w composer to do format conversion if there are cases where 
  48.              * that is more desirable than doing it in the GLES driver or at the 
  49.              * virtual display consumer. 
  50.              * 
  51.              * If some or all layers are marked OVERLAY, then the framebuffer 
  52.              * and output buffer will be different. As with physical displays, 
  53.              * the framebuffer handle will not change between frames if all 
  54.              * layers are marked for OVERLAY. 
  55.              */  
  56.             buffer_handle_t outbuf;  
  57.   
  58.             /* File descriptor for a fence that will signal when outbuf is 
  59.              * ready to be written. The h/w composer is responsible for closing 
  60.              * this when no longer needed. 
  61.              * 
  62.              * Will be -1 whenever outbuf is NULL, or when the outbuf can be 
  63.              * written immediately. 
  64.              */  
  65.             int outbufAcquireFenceFd;  
  66.         };  
  67.     };  
  68.   
  69.     /* List of layers that will be composed on the display. The buffer handles 
  70.      * in the list will be unique. If numHwLayers is 0, all composition will be 
  71.      * performed by SurfaceFlinger. 
  72.      */  
  73.     uint32_t flags;  
  74.     size_t numHwLayers;//layer个数  
  75.     hwc_layer_1_t hwLayers[0];//layer起始地址  
  76.   
  77. } hwc_display_contents_1_t;  

再来看下每个layer的数据结构体hwc_layer_1 ，其主要数据在buffer_handle_t handle中，buffer_handle_t 其实就是native_handle_t之前分析过，里面有共享内存的fd和地址。

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. typedef struct hwc_layer_1 {  
  2.     /* 
  3.      * compositionType is used to specify this layer's type and is set by either 
  4.      * the hardware composer implementation, or by the caller (see below). 
  5.      * 
  6.      *  This field is always reset to HWC_BACKGROUND or HWC_FRAMEBUFFER 
  7.      *  before (*prepare)() is called when the HWC_GEOMETRY_CHANGED flag is 
  8.      *  also set, otherwise, this field is preserved between (*prepare)() 
  9.      *  calls. 
  10.      * 
  11.      * HWC_BACKGROUND 
  12.      *   Always set by the caller before calling (*prepare)(), this value 
  13.      *   indicates this is a special "background" layer. The only valid field 
  14.      *   is backgroundColor. 
  15.      *   The HWC can toggle this value to HWC_FRAMEBUFFER to indicate it CANNOT 
  16.      *   handle the background color. 
  17.      * 
  18.      * 
  19.      * HWC_FRAMEBUFFER_TARGET 
  20.      *   Always set by the caller before calling (*prepare)(), this value 
  21.      *   indicates this layer is the framebuffer surface used as the target of 
  22.      *   OpenGL ES composition. If the HWC sets all other layers to HWC_OVERLAY 
  23.      *   or HWC_BACKGROUND, then no OpenGL ES composition will be done, and 
  24.      *   this layer should be ignored during set(). 
  25.      * 
  26.      *   This flag (and the framebuffer surface layer) will only be used if the 
  27.      *   HWC version is HWC_DEVICE_API_VERSION_1_1 or higher. In older versions, 
  28.      *   the OpenGL ES target surface is communicated by the (dpy, sur) fields 
  29.      *   in hwc_compositor_device_1_t. 
  30.      * 
  31.      *   This value cannot be set by the HWC implementation. 
  32.      * 
  33.      * 
  34.      * HWC_FRAMEBUFFER 
  35.      *   Set by the caller before calling (*prepare)() ONLY when the 
  36.      *   HWC_GEOMETRY_CHANGED flag is also set. 
  37.      * 
  38.      *   Set by the HWC implementation during (*prepare)(), this indicates 
  39.      *   that the layer will be drawn into the framebuffer using OpenGL ES. 
  40.      *   The HWC can toggle this value to HWC_OVERLAY to indicate it will 
  41.      *   handle the layer. 
  42.      * 
  43.      * 
  44.      * HWC_OVERLAY 
  45.      *   Set by the HWC implementation during (*prepare)(), this indicates 
  46.      *   that the layer will be handled by the HWC (ie: it must not be 
  47.      *   composited with OpenGL ES). 
  48.      * 
  49.      * 
  50.      * HWC_SIDEBAND 
  51.      *   Set by the caller before calling (*prepare)(), this value indicates 
  52.      *   the contents of this layer come from a sideband video stream. 
  53.      * 
  54.      *   The h/w composer is responsible for receiving new image buffers from 
  55.      *   the stream at the appropriate time (e.g. synchronized to a separate 
  56.      *   audio stream), compositing them with the current contents of other 
  57.      *   layers, and displaying the resulting image. This happens 
  58.      *   independently of the normal prepare/set cycle. The prepare/set calls 
  59.      *   only happen when other layers change, or when properties of the 
  60.      *   sideband layer such as position or size change. 
  61.      * 
  62.      *   If the h/w composer can't handle the layer as a sideband stream for 
  63.      *   some reason (e.g. unsupported scaling/blending/rotation, or too many 
  64.      *   sideband layers) it can set compositionType to HWC_FRAMEBUFFER in 
  65.      *   (*prepare)(). However, doing so will result in the layer being shown 
  66.      *   as a solid color since the platform is not currently able to composite 
  67.      *   sideband layers with the GPU. This may be improved in future 
  68.      *   versions of the platform. 
  69.      * 
  70.      * 
  71.      * HWC_CURSOR_OVERLAY 
  72.      *   Set by the HWC implementation during (*prepare)(), this value 
  73.      *   indicates the layer's composition will now be handled by the HWC. 
  74.      *   Additionally, the client can now asynchronously update the on-screen 
  75.      *   position of this layer using the setCursorPositionAsync() api. 
  76.      */  
  77.     int32_t compositionType;  
  78.   
  79.     /* 
  80.      * hints is bit mask set by the HWC implementation during (*prepare)(). 
  81.      * It is preserved between (*prepare)() calls, unless the 
  82.      * HWC_GEOMETRY_CHANGED flag is set, in which case it is reset to 0. 
  83.      * 
  84.      * see hwc_layer_t::hints 
  85.      */  
  86.     uint32_t hints;  
  87.   
  88.     /* see hwc_layer_t::flags */  
  89.     uint32_t flags;  
  90.   
  91.     union {  
  92.         /* color of the background.  hwc_color_t.a is ignored */  
  93.         hwc_color_t backgroundColor;  
  94.   
  95.         struct {  
  96.             union {  
  97.                 /* When compositionType is HWC_FRAMEBUFFER, HWC_OVERLAY, 
  98.                  * HWC_FRAMEBUFFER_TARGET, this is the handle of the buffer to 
  99.                  * compose. This handle is guaranteed to have been allocated 
  100.                  * from gralloc using the GRALLOC_USAGE_HW_COMPOSER usage flag. 
  101.                  * If the layer's handle is unchanged across two consecutive 
  102.                  * prepare calls and the HWC_GEOMETRY_CHANGED flag is not set 
  103.                  * for the second call then the HWComposer implementation may 
  104.                  * assume that the contents of the buffer have not changed. */  
  105.                 buffer_handle_t handle;  
  106.   
  107.                 /* When compositionType is HWC_SIDEBAND, this is the handle 
  108.                  * of the sideband video stream to compose. */  
  109.                 const native_handle_t* sidebandStream;  
  110.             };  
  111.   
  112.             /* transformation to apply to the buffer during composition */  
  113.             uint32_t transform;  
  114.   
  115.             /* blending to apply during composition */  
  116.             int32_t blending;  
  117.   
  118.             /* area of the source to consider, the origin is the top-left corner of 
  119.              * the buffer. As of HWC_DEVICE_API_VERSION_1_3, sourceRect uses floats. 
  120.              * If the h/w can't support a non-integer source crop rectangle, it should 
  121.              * punt to OpenGL ES composition. 
  122.              */  
  123.             union {  
  124.                 // crop rectangle in integer (pre HWC_DEVICE_API_VERSION_1_3)  
  125.                 hwc_rect_t sourceCropi;  
  126.                 hwc_rect_t sourceCrop; // just for source compatibility  
  127.                 // crop rectangle in floats (as of HWC_DEVICE_API_VERSION_1_3)  
  128.                 hwc_frect_t sourceCropf;  
  129.             };  
  130.   
  131.             /* where to composite the sourceCrop onto the display. The sourceCrop 
  132.              * is scaled using linear filtering to the displayFrame. The origin is the 
  133.              * top-left corner of the screen. 
  134.              */  
  135.             hwc_rect_t displayFrame;  
  136.   
  137.             /* visible region in screen space. The origin is the 
  138.              * top-left corner of the screen. 
  139.              * The visible region INCLUDES areas overlapped by a translucent layer. 
  140.              */  
  141.             hwc_region_t visibleRegionScreen;  
  142.   
  143.             /* Sync fence object that will be signaled when the buffer's 
  144.              * contents are available. May be -1 if the contents are already 
  145.              * available. This field is only valid during set(), and should be 
  146.              * ignored during prepare(). The set() call must not wait for the 
  147.              * fence to be signaled before returning, but the HWC must wait for 
  148.              * all buffers to be signaled before reading from them. 
  149.              * 
  150.              * HWC_FRAMEBUFFER layers will never have an acquire fence, since 
  151.              * reads from them are complete before the framebuffer is ready for 
  152.              * display. 
  153.              * 
  154.              * HWC_SIDEBAND layers will never have an acquire fence, since 
  155.              * synchronization is handled through implementation-defined 
  156.              * sideband mechanisms. 
  157.              * 
  158.              * The HWC takes ownership of the acquireFenceFd and is responsible 
  159.              * for closing it when no longer needed. 
  160.              */  
  161.             int acquireFenceFd;  
  162.   
  163.             /* During set() the HWC must set this field to a file descriptor for 
  164.              * a sync fence object that will signal after the HWC has finished 
  165.              * reading from the buffer. The field is ignored by prepare(). Each 
  166.              * layer should have a unique file descriptor, even if more than one 
  167.              * refer to the same underlying fence object; this allows each to be 
  168.              * closed independently. 
  169.              * 
  170.              * If buffer reads can complete at significantly different times, 
  171.              * then using independent fences is preferred. For example, if the 
  172.              * HWC handles some layers with a blit engine and others with 
  173.              * overlays, then the blit layers can be reused immediately after 
  174.              * the blit completes, but the overlay layers can't be reused until 
  175.              * a subsequent frame has been displayed. 
  176.              * 
  177.              * Since HWC doesn't read from HWC_FRAMEBUFFER layers, it shouldn't 
  178.              * produce a release fence for them. The releaseFenceFd will be -1 
  179.              * for these layers when set() is called. 
  180.              * 
  181.              * Since HWC_SIDEBAND buffers don't pass through the HWC client, 
  182.              * the HWC shouldn't produce a release fence for them. The 
  183.              * releaseFenceFd will be -1 for these layers when set() is called. 
  184.              * 
  185.              * The HWC client taks ownership of the releaseFenceFd and is 
  186.              * responsible for closing it when no longer needed. 
  187.              */  
  188.             int releaseFenceFd;  
  189.   
  190.             /* 
  191.              * Availability: HWC_DEVICE_API_VERSION_1_2 
  192.              * 
  193.              * Alpha value applied to the whole layer. The effective 
  194.              * value of each pixel is computed as: 
  195.              * 
  196.              *   if (blending == HWC_BLENDING_PREMULT) 
  197.              *      pixel.rgb = pixel.rgb * planeAlpha / 255 
  198.              *   pixel.a = pixel.a * planeAlpha / 255 
  199.              * 
  200.              * Then blending proceeds as usual according to the "blending" 
  201.              * field above. 
  202.              * 
  203.              * NOTE: planeAlpha applies to YUV layers as well: 
  204.              * 
  205.              *   pixel.rgb = yuv_to_rgb(pixel.yuv) 
  206.              *   if (blending == HWC_BLENDING_PREMULT) 
  207.              *      pixel.rgb = pixel.rgb * planeAlpha / 255 
  208.              *   pixel.a = planeAlpha 
  209.              * 
  210.              * 
  211.              * IMPLEMENTATION NOTE: 
  212.              * 
  213.              * If the source image doesn't have an alpha channel, then 
  214.              * the h/w can use the HWC_BLENDING_COVERAGE equations instead of 
  215.              * HWC_BLENDING_PREMULT and simply set the alpha channel to 
  216.              * planeAlpha. 
  217.              * 
  218.              * e.g.: 
  219.              * 
  220.              *   if (blending == HWC_BLENDING_PREMULT) 
  221.              *      blending = HWC_BLENDING_COVERAGE; 
  222.              *   pixel.a = planeAlpha; 
  223.              * 
  224.              */  
  225.             uint8_t planeAlpha;  
  226.   
  227.             /* Pad to 32 bits */  
  228.             uint8_t _pad[3];  
  229.   
  230.             /* 
  231.              * Availability: HWC_DEVICE_API_VERSION_1_5 
  232.              * 
  233.              * This defines the region of the source buffer that has been 
  234.              * modified since the last frame. 
  235.              * 
  236.              * If surfaceDamage.numRects > 0, then it may be assumed that any 
  237.              * portion of the source buffer not covered by one of the rects has 
  238.              * not been modified this frame. If surfaceDamage.numRects == 0, 
  239.              * then the whole source buffer must be treated as if it had been 
  240.              * modified. 
  241.              * 
  242.              * If the layer's contents are not modified relative to the prior 
  243.              * prepare/set cycle, surfaceDamage will contain exactly one empty 
  244.              * rect ([0, 0, 0, 0]). 
  245.              * 
  246.              * The damage rects are relative to the pre-transformed buffer, and 
  247.              * their origin is the top-left corner. 
  248.              */  
  249.             hwc_region_t surfaceDamage;  
  250.         };  
  251.     };  
  252.   
  253. #ifdef __LP64__  
  254.     /* 
  255.      * For 64-bit mode, this struct is 120 bytes (and 8-byte aligned), and needs 
  256.      * to be padded as such to maintain binary compatibility. 
  257.      */  
  258.     uint8_t reserved[120 - 112];  
  259. #else  
  260.     /* 
  261.      * For 32-bit mode, this struct is 96 bytes, and needs to be padded as such 
  262.      * to maintain binary compatibility. 
  263.      */  
  264.     uint8_t reserved[96 - 84];  
  265. #endif  
  266.   
  267. } hwc_layer_1_t;  

回到setUpHWComposer函数，下面是变量所有的设备上的layer调用其setPerFrameData函数。

在分析setPerFrameData之前我们先分析下setUpHWComposer中的遍历Layer时候用到的cur和end。我把这段代码单独拿出来。

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. HWComposer::LayerListIterator cur = hwc.begin(id);  
  2. const HWComposer::LayerListIterator end = hwc.end(id);  
  3. for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {  
  4.     /* 
  5.      * update the per-frame h/w composer data for each layer 
  6.      * and build the transparent region of the FB 
  7.      */  
  8.     const sp<Layer>& layer(currentLayers[i]);  
  9.     layer->setPerFrameData(hw, *cur);  
  10. }  
看下HWComposer中的begin函数
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. HWComposer::LayerListIterator HWComposer::begin(int32_t id) {  
  2.     return getLayerIterator(id, 0);  
  3. }  

再来看下getLayerIterator函数，正常应该是最后一个分支。注意这个时候index是0

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. HWComposer::LayerListIterator HWComposer::getLayerIterator(int32_t id, size_t index) {  
  2.     if (uint32_t(id)>31 || !mAllocatedDisplayIDs.hasBit(id)) {  
  3.         return LayerListIterator();  
  4.     }  
  5.     const DisplayData& disp(mDisplayData[id]);  
  6.     if (!mHwc || !disp.list || index > disp.list->numHwLayers) {  
  7.         return LayerListIterator();  
  8.     }  
  9.     return LayerListIterator(new HWCLayerVersion1(mHwc, disp.list->hwLayers), index);  
  10. }  
新建了一个LayerListIterator，这里面HWCLayerVersion1就是mLayerList， index就是mIndex. 我们看下*符号的重载，因为我们后面用到了，就是mLayerList。
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. class LayerListIterator {  
  2.     friend class HWComposer;  
  3.     HWCLayer* const mLayerList;  
  4.     size_t mIndex;  
  5.   
  6.     LayerListIterator() : mLayerList(NULL), mIndex(0) { }  
  7.   
  8.     LayerListIterator(HWCLayer* layer, size_t index)  
  9.         : mLayerList(layer), mIndex(index) { }  
  10.   
  11.     // we don't allow assignment, because we don't need it for now  
  12.     LayerListIterator& operator = (const LayerListIterator& rhs);  
  13.   
  14. public:  
  15.     // copy operators  
  16.     LayerListIterator(const LayerListIterator& rhs)  
  17.         : mLayerList(HWCLayer::copy(rhs.mLayerList)), mIndex(rhs.mIndex) {  
  18.     }  
  19.   
  20.     ~LayerListIterator() { delete mLayerList; }  
  21.   
  22.     // pre-increment  
  23.     LayerListIterator& operator++() {  
  24.         mLayerList->setLayer(++mIndex);  
  25.         return *this;  
  26.     }  
  27.   
  28.     // dereference  
  29.     HWCLayerInterface& operator * () { return *mLayerList; }  
  30.     HWCLayerInterface* operator -> () { return mLayerList; }  
  31.   
  32.     // comparison  
  33.     bool operator == (const LayerListIterator& rhs) const {  
  34.         return mIndex == rhs.mIndex;  
  35.     }  
  36.     bool operator != (const LayerListIterator& rhs) const {  
  37.         return !operator==(rhs);  
  38.     }  
  39. };  
而上面的mLayerList就是HWCLayerVersion1对象。

而我们再来看看下HWComposer中的end函数，end函数和begin很像只是在调用getLayerIterator的时候，begin传入0，end传入layer的最后一位。最后就是mIndex成员变量不一样

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. HWComposer::LayerListIterator HWComposer::end(int32_t id) {  
  2.     size_t numLayers = 0;  
  3.     if (uint32_t(id) <= 31 && mAllocatedDisplayIDs.hasBit(id)) {  
  4.         const DisplayData& disp(mDisplayData[id]);  
  5.         if (mHwc && disp.list) {  
  6.             numLayers = disp.list->numHwLayers;//获取到list中laye的个数  
  7.             if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {  
  8.                 // with HWC 1.1, the last layer is always the HWC_FRAMEBUFFER_TARGET,  
  9.                 // which we ignore when iterating through the layer list.  
  10.                 ALOGE_IF(!numLayers, "mDisplayData[%d].list->numHwLayers is 0", id);  
  11.                 if (numLayers) {  
  12.                     numLayers--;//变成最后一位  
  13.                 }  
  14.             }  
  15.         }  
  16.     }  
  17.     return getLayerIterator(id, numLayers);//和上面一样，只是传入的index不一样。  
  18. }  

我们再来看LayerListIterator操作符++的重载，会调用mLayerList->setLayer函数

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. LayerListIterator& operator++() {  
  2.     mLayerList->setLayer(++mIndex);  
  3.     return *this;  
  4. }  
setLayer会从mLayerList中设置当前的mCurrentLayer，通过mLayerList, 这个变量就是disp.list->hwLayers
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. virtual status_t setLayer(size_t index) {  
  2.     mCurrentLayer = &mLayerList[index];  
  3.     return NO_ERROR;  
  4. }  
这样准备工作就好了，我们再来分析Layer的setPerFrameData函数，主要就是调用了HWCLayerVersion1的setBuffer函数
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. void Layer::setPerFrameData(const sp<const DisplayDevice>& hw,  
  2.         HWComposer::HWCLayerInterface& layer) {  
  3.     // we have to set the visible region on every frame because  
  4.     // we currently free it during onLayerDisplayed(), which is called  
  5.     // after HWComposer::commit() -- every frame.  
  6.     // Apply this display's projection's viewport to the visible region  
  7.     // before giving it to the HWC HAL.  
  8.     const Transform& tr = hw->getTransform();  
  9.     Region visible = tr.transform(visibleRegion.intersect(hw->getViewport()));  
  10.     layer.setVisibleRegionScreen(visible);  
  11.     layer.setSurfaceDamage(surfaceDamageRegion);  
  12.   
  13.     if (mSidebandStream.get()) {  
  14.         layer.setSidebandStream(mSidebandStream);  
  15.     } else {  
  16.         // NOTE: buffer can be NULL if the client never drew into this  
  17.         // layer yet, or if we ran out of memory  
  18.         layer.setBuffer(mActiveBuffer);  
  19.     }  
  20. }  
再来看HWCLayerVersion1的setBuffer函数，调用getLayer函数设置其handle，而getLayer就是mCurrentLayer。之前mCurrentLayer会一个个遍历各个Layer,这样就把所有的layer都设置其handle，就是hwc_layer_1_t中的handle。
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. virtual void setBuffer(const sp<GraphicBuffer>& buffer) {  
  2.     if (buffer == 0 || buffer->handle == 0) {  
  3.         getLayer()->compositionType = HWC_FRAMEBUFFER;  
  4.         getLayer()->flags |= HWC_SKIP_LAYER;  
  5.         getLayer()->handle = 0;  
  6.     } else {  
  7.         if (getLayer()->compositionType == HWC_SIDEBAND) {  
  8.             // If this was a sideband layer but the stream was removed, reset  
  9.             // it to FRAMEBUFFER. The HWC can change it to OVERLAY in prepare.  
  10.             getLayer()->compositionType = HWC_FRAMEBUFFER;  
  11.         }  
  12.         getLayer()->handle = buffer->handle;  
  13.     }  
  14. }  
最后会调用HWComposer的prepare函数，我们再来看下这个函数。这里我们先将DisplayData的framebufferTarget的composition设置为HWC_FRAMEBUFFER_TARGET，然后将每个DisplayData的list放入mList中。最后调用了mHwc的prepare函数。
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. status_t HWComposer::prepare() {  
  2.     Mutex::Autolock _l(mDisplayLock);  
  3.     for (size_t i=0 ; i<mNumDisplays ; i++) {  
  4.         DisplayData& disp(mDisplayData[i]);  
  5.         if (disp.framebufferTarget) {//这里其实就是disp.list中最后一个layer  
  6.             // make sure to reset the type to HWC_FRAMEBUFFER_TARGET  
  7.             // DO NOT reset the handle field to NULL, because it's possible  
  8.             // that we have nothing to redraw (eg: eglSwapBuffers() not called)  
  9.             // in which case, we should continue to use the same buffer.  
  10.             LOG_FATAL_IF(disp.list == NULL);  
  11.             disp.framebufferTarget->compositionType = HWC_FRAMEBUFFER_TARGET;  
  12.         }  
  13.         if (!disp.connected && disp.list != NULL) {  
  14.             ALOGW("WARNING: disp %zu: connected, non-null list, layers=%zu",  
  15.                   i, disp.list->numHwLayers);  
  16.         }  
  17.         mLists[i] = disp.list;//DisplayData的list就是mList的一个组员  
  18.         if (mLists[i]) {  
  19.             if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_3)) {  
  20.                 mLists[i]->outbuf = disp.outbufHandle;  
  21.                 mLists[i]->outbufAcquireFenceFd = -1;  
  22.             } else if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {  
  23.                 // garbage data to catch improper use  
  24.                 mLists[i]->dpy = (hwc_display_t)0xDEADBEEF;  
  25.                 mLists[i]->sur = (hwc_surface_t)0xDEADBEEF;  
  26.             } else {  
  27.                 mLists[i]->dpy = EGL_NO_DISPLAY;  
  28.                 mLists[i]->sur = EGL_NO_SURFACE;  
  29.             }  
  30.         }  
  31.     }  
  32.   
  33.     int err = mHwc->prepare(mHwc, mNumDisplays, mLists);//调用Hwc模块的prepare函数  
  34.     ALOGE_IF(err, "HWComposer: prepare failed (%s)", strerror(-err));  
  35.   
  36.     if (err == NO_ERROR) {  
  37.         // here we're just making sure that "skip" layers are set  
  38.         // to HWC_FRAMEBUFFER and we're also counting how many layers  
  39.         // we have of each type.  
  40.         //  
  41.         // If there are no window layers, we treat the display has having FB  
  42.         // composition, because SurfaceFlinger will use GLES to draw the  
  43.         // wormhole region.  
  44.         for (size_t i=0 ; i<mNumDisplays ; i++) {  
  45.             DisplayData& disp(mDisplayData[i]);  
  46.             disp.hasFbComp = false;  
  47.             disp.hasOvComp = false;  
  48.             if (disp.list) {  
  49.                 for (size_t i=0 ; i<disp.list->numHwLayers ; i++) {  
  50.                     hwc_layer_1_t& l = disp.list->hwLayers[i];  
  51.   
  52.                     //ALOGD("prepare: %d, type=%d, handle=%p",  
  53.                     //        i, l.compositionType, l.handle);  
  54.   
  55.                     if (l.flags & HWC_SKIP_LAYER) {  
  56.                         l.compositionType = HWC_FRAMEBUFFER;  
  57.                     }  
  58.                     if (l.compositionType == HWC_FRAMEBUFFER) {  
  59.                         disp.hasFbComp = true;  
  60.                     }  
  61.                     if (l.compositionType == HWC_OVERLAY) {  
  62.                         disp.hasOvComp = true;  
  63.                     }  
  64.                     if (l.compositionType == HWC_CURSOR_OVERLAY) {  
  65.                         disp.hasOvComp = true;  
  66.                     }  
  67.                 }  
  68.                 if (disp.list->numHwLayers == (disp.framebufferTarget ? 1 : 0)) {  
  69.                     disp.hasFbComp = true;  
  70.                 }  
  71.             } else {  
  72.                 disp.hasFbComp = true;  
  73.             }  
  74.         }  
  75.     }  
  76.     return (status_t)err;  
  77. }  
mHwc的prepare主要将每个Layer的composition设置为HWC_FRAMEBUFFER。

posted @ 2016-11-27 08:15  张同光  阅读(679)  评论(0)  编辑  收藏  举报