Android6.0 顯示系統（五） SurfaceFlinger服務

very_on發表於2018-03-12
Android

SurfaceFlinger是一個獨立的程式，我們來看下init.rc關於SurfaceFlinger的程式碼，我們可以看到SurfaceFlinger是屬於core服務的。

[html] view plain copy
  1. service surfaceflinger /system/bin/surfaceflinger  
  2.     class core  
  3.     user system  
  4.     group graphics drmrpc  
  5.     onrestart restart zygote  
  6.     writepid /dev/cpuset/system-background/tasks  


一、SurfaceFlinger的啟動過程

SurfaceFlinger的main函式在framework/native/services/surfaceflinger/main_surfaceflinger.cpp中

[cpp] view plain copy
  1. int main(int, char**) {  
  2.     // When SF is launched in its own process, limit the number of  
  3.     // binder threads to 4.  
  4.     ProcessState::self()->setThreadPoolMaxThreadCount(4);//設定了Binder執行緒池最大執行緒為4  
  5.   
  6.     // start the thread pool  
  7.     sp<ProcessState> ps(ProcessState::self());  
  8.     ps->startThreadPool();  
  9.   
  10.     // instantiate surfaceflinger  
  11.     sp<SurfaceFlinger> flinger = new SurfaceFlinger();//建立SurfaceFlinger物件  
  12.   
  13.     setpriority(PRIO_PROCESS, 0, PRIORITY_URGENT_DISPLAY);  
  14.   
  15.     set_sched_policy(0, SP_FOREGROUND);  
  16.   
  17.     // initialize before clients can connect  
  18.     flinger->init();//呼叫SurfaceFlinger的init函式  
  19.   
  20.     // publish surface flinger  
  21.     sp<IServiceManager> sm(defaultServiceManager());  
  22.     sm->addService(String16(SurfaceFlinger::getServiceName()), flinger, false);//像serviceManager註冊SurfaceFlinger服務  
  23.   
  24.     // run in this thread  
  25.     flinger->run();//執行  
  26.   
  27.     return 0;  
  28. }  

在主函式中先設定了該程式的binder執行緒池最大數為4，然後建立了SurfaceFlinger物件，並且呼叫了其init函式，接著把SurfaceFlinger服務註冊到ServiceManager中，然後呼叫了run方法。

我們先來看下init函式

[cpp] view plain copy
  1. void SurfaceFlinger::init() {  
  2.     ALOGI(  "SurfaceFlinger's main thread ready to run. "  
  3.             "Initializing graphics H/W...");  
  4.   
  5.     Mutex::Autolock _l(mStateLock);  
  6.   
  7.     // initialize EGL for the default display 將EGL初始化成預設的顯示  
  8.     mEGLDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);  
  9.     eglInitialize(mEGLDisplay, NULL, NULL);  
  10.   
  11.     // start the EventThread  
  12.     sp<VSyncSource> vsyncSrc = new DispSyncSource(&mPrimaryDispSync,  
  13.             vsyncPhaseOffsetNs, true, "app");  
  14.     mEventThread = new EventThread(vsyncSrc);  
  15.     sp<VSyncSource> sfVsyncSrc = new DispSyncSource(&mPrimaryDispSync,  
  16.             sfVsyncPhaseOffsetNs, true, "sf");  
  17.     mSFEventThread = new EventThread(sfVsyncSrc);  
  18.     mEventQueue.setEventThread(mSFEventThread);  
  19.   
  20.     // Initialize the H/W composer object.  There may or may not be an  
  21.     // actual hardware composer underneath.  
  22.     mHwc = new HWComposer(this,//顯示硬體抽象類  
  23.             *static_cast<HWComposer::EventHandler *>(this));  
  24.   
  25.     // get a RenderEngine for the given display / config (can't fail)  
  26.     mRenderEngine = RenderEngine::create(mEGLDisplay, mHwc->getVisualID());  
  27.   
  28.     // retrieve the EGL context that was selected/created  
  29.     mEGLContext = mRenderEngine->getEGLContext();  
  30.   
  31.     LOG_ALWAYS_FATAL_IF(mEGLContext == EGL_NO_CONTEXT,  
  32.             "couldn't create EGLContext");  
  33.   
  34.     // initialize our non-virtual displays 初始化顯示裝置  
  35.     for (size_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) {  
  36.         DisplayDevice::DisplayType type((DisplayDevice::DisplayType)i);  
  37.         // set-up the displays that are already connected  
  38.         if (mHwc->isConnected(i) || type==DisplayDevice::DISPLAY_PRIMARY) {  
  39.             // All non-virtual displays are currently considered secure.  
  40.             bool isSecure = true;  
  41.             createBuiltinDisplayLocked(type);  
  42.             wp<IBinder> token = mBuiltinDisplays[i];  
  43.   
  44.             sp<IGraphicBufferProducer> producer;  
  45.             sp<IGraphicBufferConsumer> consumer;  
  46.             BufferQueue::createBufferQueue(&producer, &consumer,  
  47.                     new GraphicBufferAlloc());  
  48.   
  49.             sp<FramebufferSurface> fbs = new FramebufferSurface(*mHwc, i,  
  50.                     consumer);  
  51.             int32_t hwcId = allocateHwcDisplayId(type);  
  52.             sp<DisplayDevice> hw = new DisplayDevice(this,  
  53.                     type, hwcId, mHwc->getFormat(hwcId), isSecure, token,  
  54.                     fbs, producer,  
  55.                     mRenderEngine->getEGLConfig());  
  56.             if (i > DisplayDevice::DISPLAY_PRIMARY) {  
  57.                 // FIXME: currently we don't get blank/unblank requests  
  58.                 // for displays other than the main display, so we always  
  59.                 // assume a connected display is unblanked.  
  60.                 ALOGD("marking display %zu as acquired/unblanked", i);  
  61.                 hw->setPowerMode(HWC_POWER_MODE_NORMAL);  
  62.             }  
  63.             mDisplays.add(token, hw);  
  64.         }  
  65.     }  
  66.   
  67.     // make the GLContext current so that we can create textures when creating Layers  
  68.     // (which may happens before we render something)  
  69.     getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext);  
  70.   
  71.     mEventControlThread = new EventControlThread(this);  
  72.     mEventControlThread->run("EventControl", PRIORITY_URGENT_DISPLAY);  
  73.   
  74.     // set a fake vsync period if there is no HWComposer  
  75.     if (mHwc->initCheck() != NO_ERROR) {  
  76.         mPrimaryDispSync.setPeriod(16666667);  
  77.     }  
  78.   
  79.     // initialize our drawing state  
  80.     mDrawingState = mCurrentState;  
  81.   
  82.     // set initial conditions (e.g. unblank default device)  
  83.     initializeDisplays();//初始化顯示裝置  
  84.   
  85.     // start boot animation  
  86.     startBootAnim();//啟動開機動畫  
  87. }  

init函式主要工作：

1.初始化OpenGL ES圖形庫。

2. 建立顯示裝置的抽象代表，負責和顯示裝置打交道。

3. 建立顯示裝置物件。

4. 啟動EventThread。監聽和處理SurfaceFlinger中的事件。

5.設定軟體VSync訊號週期。

6.初始化顯示裝置，呼叫initializeDisplays完成。

7.啟動開機動畫，呼叫了startBootAnim函式，只是設定了兩個屬性，其中一個ctl.start是啟動了bootanim程式。

[cpp] view plain copy
  1. void SurfaceFlinger::startBootAnim() {  
  2.     // start boot animation  
  3.     property_set("service.bootanim.exit", "0");  
  4.     property_set("ctl.start", "bootanim");  
  5. }  


二、訊息和事件分發 MessageQueue和EventThread

MessageQueue和用於訊息和事件的分發，這個和之前部落格分析過得訊息機制原理差不多。

我們先來看看MessageQueue的主要成員變數

[cpp] view plain copy
  1. class MessageQueue {  
  2.     ......  
  3.     sp<SurfaceFlinger> mFlinger;//指向SurfaceFlinger  
  4.     sp<Looper> mLooper;//訊息機制Looper物件  
  5.     sp<EventThread> mEventThread;//關聯的EventThread  
  6.     sp<IDisplayEventConnection> mEvents;  
  7.     sp<BitTube> mEventTube;  
  8.     sp<Handler> mHandler;//訊息處理器  
其中mEventThread主要是用來分析VSync訊號的。

在SurfaceFlinger中有一個型別為MessageQueue的成員變數mEventQueue，在SurfaceFlinger的onFirstRef函式中會呼叫其init函式

[cpp] view plain copy
  1. void SurfaceFlinger::onFirstRef()  
  2. {  
  3.     mEventQueue.init(this);  
  4. }  
在這個函式中建立了Looper和Handler物件，並且把flinger儲存在mFlinger中。

[cpp] view plain copy
  1. void MessageQueue::init(const sp<SurfaceFlinger>& flinger)  
  2. {  
  3.     mFlinger = flinger;  
  4.     mLooper = new Looper(true);  
  5.     mHandler = new Handler(*this);  
  6. }  
我們來看下Handler這個類，它是MessageQueue類的一個內部類，這個類主要處理3個訊息。

[cpp] view plain copy
  1. class Handler : public MessageHandler {  
  2.     enum {  
  3.         eventMaskInvalidate     = 0x1,//invalidate訊息  
  4.         eventMaskRefresh        = 0x2,//重新整理訊息  
  5.         eventMaskTransaction    = 0x4  
  6.     };  
  7.     MessageQueue& mQueue;  
  8.     int32_t mEventMask;  
  9. public:  
  10.     Handler(MessageQueue& queue) : mQueue(queue), mEventMask(0) { }  
  11.     virtual void handleMessage(const Message& message);  
  12.     void dispatchRefresh();  
  13.     void dispatchInvalidate();  
  14.     void dispatchTransaction();  
  15. };  


我們再來看在SurfaceFlinger主函式最後呼叫了下面方法。

[cpp] view plain copy
  1. flinger->run();  

SurfaceFlinger::run程式碼如下

[cpp] view plain copy
  1. void SurfaceFlinger::run() {  
  2.     do {  
  3.         waitForEvent();  
  4.     } while (true);  
  5. }  

waitForEvent函式如下：

[cpp] view plain copy
  1. void SurfaceFlinger::waitForEvent() {  
  2.     mEventQueue.waitMessage();  
  3. }  

然後又呼叫了EventQueue的waitMessage方法，記住這裡是在主執行緒中迴圈呼叫的。

下面我們來看下waitMessage方法，flushCommands之前在分析Binder的部落格中有提到，主要是清理工作的，和Binder驅動的互動關了。而pollOnce是訊息機制，主要呼叫了epoll_wait函式，會阻塞，阻塞完了會分發訊息佇列中的訊息。這裡的訊息只有自己在Handler中發的訊息，還有在setEventThread中自己新增的fd。

[cpp] view plain copy
  1. void MessageQueue::waitMessage() {  
  2.     do {  
  3.         IPCThreadState::self()->flushCommands();  
  4.         int32_t ret = mLooper->pollOnce(-1);  
  5.         switch (ret) {  
  6.             case Looper::POLL_WAKE:  
  7.             case Looper::POLL_CALLBACK:  
  8.                 continue;  
  9.             case Looper::POLL_ERROR:  
  10.                 ALOGE("Looper::POLL_ERROR");  
  11.             case Looper::POLL_TIMEOUT:  
  12.                 // timeout (should not happen)  
  13.                 continue;  
  14.             default:  
  15.                 // should not happen  
  16.                 ALOGE("Looper::pollOnce() returned unknown status %d", ret);  
  17.                 continue;  
  18.         }  
  19.     } while (true);  
  20. }  

下面是Handler中傳送訊息，這個會在pollOnce中處理。

[cpp] view plain copy
  1. void MessageQueue::Handler::dispatchRefresh() {  
  2.     if ((android_atomic_or(eventMaskRefresh, &mEventMask) & eventMaskRefresh) == 0) {  
  3.         mQueue.mLooper->sendMessage(this, Message(MessageQueue::REFRESH));  
  4.     }  
  5. }  
  6.   
  7. void MessageQueue::Handler::dispatchInvalidate() {  
  8.     if ((android_atomic_or(eventMaskInvalidate, &mEventMask) & eventMaskInvalidate) == 0) {  
  9.         mQueue.mLooper->sendMessage(this, Message(MessageQueue::INVALIDATE));  
  10.     }  
  11. }  
  12.   
  13. void MessageQueue::Handler::dispatchTransaction() {  
  14.     if ((android_atomic_or(eventMaskTransaction, &mEventMask) & eventMaskTransaction) == 0) {  
  15.         mQueue.mLooper->sendMessage(this, Message(MessageQueue::TRANSACTION));  
  16.     }  
  17. }  

在SurfaceFlinger的init函式還呼叫瞭如下函式

[cpp] view plain copy
  1. mSFEventThread = new EventThread(sfVsyncSrc);  
  2. mEventQueue.setEventThread(mSFEventThread);  

我們來看setEventThread函式會呼叫Looper的addFd，這個最終也會在pollOnce中執行。mEventThread是一個EventThread物件，呼叫createEventConnection來建立一個連線。EventThread是一個執行緒類用來分發VSync訊息。這個我們後面講解VSync訊號的時候還會詳細分析。

[cpp] view plain copy
  1. void MessageQueue::setEventThread(const sp<EventThread>& eventThread)  
  2. {  
  3.     mEventThread = eventThread;  
  4.     mEvents = eventThread->createEventConnection();  
  5.     mEventTube = mEvents->getDataChannel();  
  6.     mLooper->addFd(mEventTube->getFd(), 0, Looper::EVENT_INPUT,  
  7.             MessageQueue::cb_eventReceiver, this);  
  8. }  


三、顯示裝置  DisplayDevice類

DisplayDevice是顯示裝置的抽象，定義了3中型別的顯示裝置。

1.DISPLAY_PRIMARY：主顯示裝置，通常是LCD屏

2.DISPLAY_EXTERNAL：擴充套件顯示裝置。通過HDMI輸出的顯示訊號

3.DISPLAY_VIRTUAL：虛擬顯示裝置，通過WIFI輸出訊號
這3鍾裝置，第一種是基本配置，另外兩種需要硬體支援。這裡我們主要講解第一種。


SurfaceFlinger中需要顯示的圖層（layer）將通過DisplayDevice物件傳遞到OpenGLES中進行合成，合成之後的影象再通過HWComposer物件傳遞到Framebuffer中顯示。DisplayDevice物件中的成員變數mVisibleLayersSortedByZ儲存了所有需要顯示在本顯示裝置中顯示的Layer物件，同時DisplayDevice物件也儲存了和顯示裝置相關的顯示方向、顯示區域座標等資訊。

上節在SurfaceFlinger的init函式中有一段程式碼來建立DisplayDevice物件

[cpp] view plain copy
  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,  
  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,  
  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. }  

所有顯示裝置的輸出都要通過HWComposer物件完成，因此上面這段程式碼先呼叫了HWComposer的isConnected來檢查顯示裝置是否已連線，只有和顯示裝置連線的DisplayDevice物件才會被建立出來。即使沒有任何物理顯示裝置被檢測到，SurfaceFlinger都需要一個DisplayDevice物件才能正常工作，因此，DISPLAY_PRIMARY型別的DisplayDevice物件總是會被建立出來。

createBuiltinDisplayLocked函式就是為顯示裝置物件建立一個BBinder型別的Token而已。

[cpp] view plain copy
  1. void SurfaceFlinger::createBuiltinDisplayLocked(DisplayDevice::DisplayType type) {  
  2.     ALOGW_IF(mBuiltinDisplays[type],  
  3.             "Overwriting display token for display type %d", type);  
  4.     mBuiltinDisplays[type] = new BBinder();  
  5.     DisplayDeviceState info(type);  
  6.     // All non-virtual displays are currently considered secure.  
  7.     info.isSecure = true;  
  8.     mCurrentState.displays.add(mBuiltinDisplays[type], info);  
  9. }  

然後會呼叫createBufferQueue函式建立一個producer和consumer，這個之前分析過。然後又建立了一個FramebufferSurface物件。這裡我們看到在新建FramebufferSurface物件時把consumer引數傳入了代表是一個消費者。而在DisplayDevice的建構函式中，會建立一個Surface物件傳遞給底層的OpenGL ES使用，而這個Surface是一個生產者。在OpenGl ES中合成好了影象之後會將影象資料寫到Surface物件中，這將觸發consumer物件的onFrameAvailable函式被呼叫：

這就是Surface資料好了就通知消費者來拿資料做顯示用，在onFrameAvailable函式彙總，通過nextBuffer獲得影象資料，然後呼叫HWComposer物件mHwc的fbPost函式輸出。

[cpp] view plain copy
  1. void FramebufferSurface::onFrameAvailable(const BufferItem& /* item */) {  
  2.     sp<GraphicBuffer> buf;  
  3.     sp<Fence> acquireFence;  
  4.     status_t err = nextBuffer(buf, acquireFence);  
  5.     if (err != NO_ERROR) {  
  6.         ALOGE("error latching nnext FramebufferSurface buffer: %s (%d)",  
  7.                 strerror(-err), err);  
  8.         return;  
  9.     }  
  10.     err = mHwc.fbPost(mDisplayType, acquireFence, buf);  
  11.     if (err != NO_ERROR) {  
  12.         ALOGE("error posting framebuffer: %d", err);  
  13.     }  
  14. }  

fbPost函式最後通過呼叫Gralloc模組的post函式來輸出影象。

我們再來看看DisplayDevice的建構函式

[cpp] view plain copy
  1. DisplayDevice::DisplayDevice(  
  2.         const sp<SurfaceFlinger>& flinger,  
  3.         DisplayType type,  
  4.         int32_t hwcId,  
  5.         int format,  
  6.         bool isSecure,  
  7.         const wp<IBinder>& displayToken,  
  8.         const sp<DisplaySurface>& displaySurface,  
  9.         const sp<IGraphicBufferProducer>& producer,  
  10.         EGLConfig config)  
  11.     : lastCompositionHadVisibleLayers(false),  
  12.       mFlinger(flinger),  
  13.       mType(type), mHwcDisplayId(hwcId),  
  14.       mDisplayToken(displayToken),  
  15.       mDisplaySurface(displaySurface),  
  16.       mDisplay(EGL_NO_DISPLAY),  
  17.       mSurface(EGL_NO_SURFACE),  
  18.       mDisplayWidth(), mDisplayHeight(), mFormat(),  
  19.       mFlags(),  
  20.       mPageFlipCount(),  
  21.       mIsSecure(isSecure),  
  22.       mSecureLayerVisible(false),  
  23.       mLayerStack(NO_LAYER_STACK),  
  24.       mOrientation(),  
  25.       mPowerMode(HWC_POWER_MODE_OFF),  
  26.       mActiveConfig(0)  
  27. {  
  28.     mNativeWindow = new Surface(producer, false);//建立Surface物件  
  29.     ANativeWindow* const window = mNativeWindow.get();  
  30.   
  31.     /* 
  32.      * Create our display's surface 
  33.      */  
  34.   
  35.     EGLSurface surface;  
  36.     EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);  
  37.     if (config == EGL_NO_CONFIG) {  
  38.         config = RenderEngine::chooseEglConfig(display, format);  
  39.     }  
  40.     surface = eglCreateWindowSurface(display, config, window, NULL);  
  41.     eglQuerySurface(display, surface, EGL_WIDTH,  &mDisplayWidth);  
  42.     eglQuerySurface(display, surface, EGL_HEIGHT, &mDisplayHeight);  
  43.   
  44.     // Make sure that composition can never be stalled by a virtual display  
  45.     // consumer that isn't processing buffers fast enough. We have to do this  
  46.     // in two places:  
  47.     // * Here, in case the display is composed entirely by HWC.  
  48.     // * In makeCurrent(), using eglSwapInterval. Some EGL drivers set the  
  49.     //   window's swap interval in eglMakeCurrent, so they'll override the  
  50.     //   interval we set here.  
  51.     if (mType >= DisplayDevice::DISPLAY_VIRTUAL)//虛擬裝置不支援影象合成  
  52.         window->setSwapInterval(window, 0);  
  53.   
  54.     mConfig = config;  
  55.     mDisplay = display;  
  56.     mSurface = surface;  
  57.     mFormat  = format;  
  58.     mPageFlipCount = 0;  
  59.     mViewport.makeInvalid();  
  60.     mFrame.makeInvalid();  
  61.   
  62.     // virtual displays are always considered enabled 虛擬裝置螢幕認為是不關閉的  
  63.     mPowerMode = (mType >= DisplayDevice::DISPLAY_VIRTUAL) ?  
  64.                   HWC_POWER_MODE_NORMAL : HWC_POWER_MODE_OFF;  
  65.   
  66.     // Name the display.  The name will be replaced shortly if the display  
  67.     // was created with createDisplay().  
  68.     switch (mType) {//顯示裝置名稱  
  69.         case DISPLAY_PRIMARY:  
  70.             mDisplayName = "Built-in Screen";  
  71.             break;  
  72.         case DISPLAY_EXTERNAL:  
  73.             mDisplayName = "HDMI Screen";  
  74.             break;  
  75.         default:  
  76.             mDisplayName = "Virtual Screen";    // e.g. Overlay #n  
  77.             break;  
  78.     }  
  79.   
  80.     // initialize the display orientation transform.  
  81.     setProjection(DisplayState::eOrientationDefault, mViewport, mFrame);  
  82. }  

上面建構函式主要功能是建立了一個Surface物件mNativeWindow，同時用它作為引數建立EGLSurface物件，這個EGLSurface物件是OpenGL ES中繪圖需要的。

這樣，在DisplayDevice中就建立了一個通向Framebuffer的通道，只要向DisplayDevice的mSurface寫入資料。就會到消費者FrameBufferSurface的onFrameAvailable函式，然後到HWComposer在到Gralloc模組，最後輸出到顯示裝置。

swapBuffers函式將內部緩衝區的影象資料重新整理到顯示裝置的Framebuffer中，它通過呼叫eglSwapBuffers函式來完成緩衝區重新整理工作。但是注意呼叫swapBuffers輸出影象是在顯示裝置不支援硬體composer的情況下。

[cpp] view plain copy
  1. void DisplayDevice::swapBuffers(HWComposer& hwc) const {  
  2.     // We need to call eglSwapBuffers() if:  
  3.     //  (1) we don't have a hardware composer, or  
  4.     //  (2) we did GLES composition this frame, and either  
  5.     //    (a) we have framebuffer target support (not present on legacy  
  6.     //        devices, where HWComposer::commit() handles things); or  
  7.     //    (b) this is a virtual display  
  8.     if (hwc.initCheck() != NO_ERROR ||  
  9.             (hwc.hasGlesComposition(mHwcDisplayId) &&  
  10.              (hwc.supportsFramebufferTarget() || mType >= DISPLAY_VIRTUAL))) {  
  11.         EGLBoolean success = eglSwapBuffers(mDisplay, mSurface);  
  12.         if (!success) {  
  13.             EGLint error = eglGetError();  
  14.             if (error == EGL_CONTEXT_LOST ||  
  15.                     mType == DisplayDevice::DISPLAY_PRIMARY) {  
  16.                 LOG_ALWAYS_FATAL("eglSwapBuffers(%p, %p) failed with 0x%08x",  
  17.                         mDisplay, mSurface, error);  
  18.             } else {  
  19.                 ALOGE("eglSwapBuffers(%p, %p) failed with 0x%08x",  
  20.                         mDisplay, mSurface, error);  
  21.             }  
  22.         }  
  23.     }  
  24.     else if(hwc.supportsFramebufferTarget() || mType >= DISPLAY_VIRTUAL)  
  25.     {  
  26.         EGLBoolean success = eglSwapBuffersVIV(mDisplay, mSurface);  
  27.         if (!success) {  
  28.             EGLint error = eglGetError();  
  29.             ALOGE("eglSwapBuffersVIV(%p, %p) failed with 0x%08x",  
  30.                         mDisplay, mSurface, error);  
  31.         }  
  32.     }  
  33.   
  34.     status_t result = mDisplaySurface->advanceFrame();  
  35.     if (result != NO_ERROR) {  
  36.         ALOGE("[%s] failed pushing new frame to HWC: %d",  
  37.                 mDisplayName.string(), result);  
  38.     }  
  39. }  


四、VSync訊號的分發過程

在之前的部落格分析過，當VSync訊號到來時會呼叫HWComposer類中的vsync函式

[cpp] view plain copy
  1. void HWComposer::vsync(int disp, int64_t timestamp) {  
  2.     if (uint32_t(disp) < HWC_NUM_PHYSICAL_DISPLAY_TYPES) {  
  3.         {  
  4.             Mutex::Autolock _l(mLock);  
  5.   
  6.             // There have been reports of HWCs that signal several vsync events  
  7.             // with the same timestamp when turning the display off and on. This  
  8.             // is a bug in the HWC implementation, but filter the extra events  
  9.             // out here so they don't cause havoc downstream.  
  10.             if (timestamp == mLastHwVSync[disp]) {  
  11.                 ALOGW("Ignoring duplicate VSYNC event from HWC (t=%" PRId64 ")",  
  12.                         timestamp);  
  13.                 return;  
  14.             }  
  15.   
  16.             mLastHwVSync[disp] = timestamp;  
  17.         }  
  18.   
  19.         char tag[16];  
  20.         snprintf(tag, sizeof(tag), "HW_VSYNC_%1u", disp);  
  21.         ATRACE_INT(tag, ++mVSyncCounts[disp] & 1);  
  22.   
  23.         mEventHandler.onVSyncReceived(disp, timestamp);  
  24.     }  
  25. }  

這個函式主要是呼叫了mEventHandler.onVSyncReceived函式，讓我們先來看下mEventHandler的構造，看HWComposer的建構函式，mEventHandler是傳入的引數handler。

[cpp] view plain copy
  1. HWComposer::HWComposer(  
  2.         const sp<SurfaceFlinger>& flinger,  
  3.         EventHandler& handler)  
  4.     : mFlinger(flinger),  
  5.       mFbDev(0), mHwc(0), mNumDisplays(1),  
  6.       mCBContext(new cb_context),  
  7.       mEventHandler(handler),  
  8.       mDebugForceFakeVSync(false)  

那麼我們就要看新建HWComposer的地方了，是在SurfaceFlinger的init函式中新建的，這handler就是SurfaceFlinger物件。

[cpp] view plain copy
  1. mHwc = new HWComposer(this,  
  2.         *static_cast<HWComposer::EventHandler *>(this));  

因此上面的mEventHandler.onVSyncReceived函式，就是呼叫了SurfaceFlinger的onVSyncReceived函式

[cpp] view plain copy
  1. void SurfaceFlinger::onVSyncReceived(int type, nsecs_t timestamp) {  
  2.     bool needsHwVsync = false;  
  3.   
  4.     { // Scope for the lock  
  5.         Mutex::Autolock _l(mHWVsyncLock);  
  6.         if (type == 0 && mPrimaryHWVsyncEnabled) {  
  7.             needsHwVsync = mPrimaryDispSync.addResyncSample(timestamp);  
  8.         }  
  9.     }  
  10.   
  11.     if (needsHwVsync) {  
  12.         enableHardwareVsync();  
  13.     } else {  
  14.         disableHardwareVsync(false);  
  15.     }  
  16. }  


4.1 DispSync類

上面函式我們主要看下DispSync的addResyncSample函式，看這個函式之前先看下DispSync的建構函式，在建構函式中啟動了DispSyncThread執行緒

[cpp] view plain copy
  1. DispSync::DispSync() :  
  2.         mRefreshSkipCount(0),  
  3.         mThread(new DispSyncThread()) {  
  4.   
  5.     mThread->run("DispSync", PRIORITY_URGENT_DISPLAY + PRIORITY_MORE_FAVORABLE);  

我們再來看addResyncSample函式，將VSync訊號的時間戳儲存大搜了陣列mResyncSamples中。然後呼叫了updateModelLocked函式繼續分發VSync訊號。

[cpp] view plain copy
  1. bool DispSync::addResyncSample(nsecs_t timestamp) {  
  2.     Mutex::Autolock lock(mMutex);  
  3.   
  4.     size_t idx = (mFirstResyncSample + mNumResyncSamples) % MAX_RESYNC_SAMPLES;  
  5.     mResyncSamples[idx] = timestamp;  
  6.   
  7.     if (mNumResyncSamples < MAX_RESYNC_SAMPLES) {  
  8.         mNumResyncSamples++;  
  9.     } else {  
  10.         mFirstResyncSample = (mFirstResyncSample + 1) % MAX_RESYNC_SAMPLES;  
  11.     }  
  12.   
  13.     updateModelLocked();  
  14.   
  15.     if (mNumResyncSamplesSincePresent++ > MAX_RESYNC_SAMPLES_WITHOUT_PRESENT) {  
  16.         resetErrorLocked();  
  17.     }  
  18.   
  19.     if (kIgnorePresentFences) {  
  20.         // If we don't have the sync framework we will never have  
  21.         // addPresentFence called.  This means we have no way to know whether  
  22.         // or not we're synchronized with the HW vsyncs, so we just request  
  23.         // that the HW vsync events be turned on whenever we need to generate  
  24.         // SW vsync events.  
  25.         return mThread->hasAnyEventListeners();  
  26.     }  
  27.   
  28.     return mPeriod == 0 || mError > kErrorThreshold;  
  29. }  

updateModelLocked主要顯示利用陣列mResyncSamples中的值計算mPeriod和mPhase這兩個時間值。然後最後呼叫了mThread的updateModel函式。mThread是DispSyncThread類。

[cpp] view plain copy
  1. void DispSync::updateModelLocked() {  
  2.     if (mNumResyncSamples >= MIN_RESYNC_SAMPLES_FOR_UPDATE) {  
  3.         ......  
  4.         //計算mPeriod和mPhase  
  5.   
  6.         mThread->updateModel(mPeriod, mPhase);  
  7.     }  
  8. }  

我們來看下DispSyncThread的updateModel函式，這個函式只是儲存了引數，然後呼叫了Condition的signal喚醒執行緒。

[cpp] view plain copy
  1. void updateModel(nsecs_t period, nsecs_t phase) {  
  2.     Mutex::Autolock lock(mMutex);  
  3.     mPeriod = period;  
  4.     mPhase = phase;  
  5.     mCond.signal();  
  6. }  

我們再來看DispSyncThread的threadLoop函式，主要這個函式比較計算時間來決定是否要傳送訊號。如果沒有訊號傳送就會在mCond等待，有訊號傳送前面會在updateModel中呼叫mCond的singal函式，這裡執行緒就喚醒了。gatherCallbackInvocationsLocked函式獲取本次VSync訊號的回撥函式列表，這些回撥函式是通過DispSync類的addEventListener函式加入的。接著就呼叫fireCallbackInvocations來依次呼叫列表中所有物件的onDispSyncEvent函式。

[cpp] view plain copy
  1. virtual bool threadLoop() {  
  2.     ......  
  3.     while (true) {  
  4.         Vector<CallbackInvocation> callbackInvocations;  
  5.   
  6.         nsecs_t targetTime = 0;  
  7.   
  8.         { // Scope for lock  
  9.             ......  
  10.   
  11.             if (now < targetTime) {  
  12.                 err = mCond.waitRelative(mMutex, targetTime - now);  
  13.                 ......  
  14.             }  
  15.   
  16.             now = systemTime(SYSTEM_TIME_MONOTONIC);  
  17.             ......  
  18.   
  19.             callbackInvocations = gatherCallbackInvocationsLocked(now);  
  20.         }  
  21.   
  22.         if (callbackInvocations.size() > 0) {  
  23.             fireCallbackInvocations(callbackInvocations);  
  24.         }  
  25.     }  
  26.   
  27.     return false;  
  28. }  

fireCallbackInvocations函式就是遍歷回撥列表呼叫其onDispSyncEvent函式。

[cpp] view plain copy
  1. void fireCallbackInvocations(const Vector<CallbackInvocation>& callbacks) {  
  2.     for (size_t i = 0; i < callbacks.size(); i++) {  
  3.         callbacks[i].mCallback->onDispSyncEvent(callbacks[i].mEventTime);  
  4.     }  
  5. }  


4.2 EventThread和DispSync的關係

這裡我們先不往下分析DispSync遍歷呼叫回撥，我們先來看看EventThread的threadLoop函式，這個函式邏輯很簡單。呼叫waitForEvent來獲取事件，然後呼叫每個連線的postEvent來傳送Event。

[cpp] view plain copy
  1. bool EventThread::threadLoop() {  
  2.     DisplayEventReceiver::Event event;  
  3.     Vector< sp<EventThread::Connection> > signalConnections;  
  4.     signalConnections = waitForEvent(&event);//獲取Event  
  5.   
  6.     // dispatch events to listeners...  
  7.     const size_t count = signalConnections.size();  
  8.     for (size_t i=0 ; i<count ; i++) {  
  9.         const sp<Connection>& conn(signalConnections[i]);  
  10.         // now see if we still need to report this event  
  11.         status_t err = conn->postEvent(event);//傳送Event  
  12.         if (err == -EAGAIN || err == -EWOULDBLOCK) {  
  13.             // The destination doesn't accept events anymore, it's probably  
  14.             // full. For now, we just drop the events on the floor.  
  15.             // FIXME: Note that some events cannot be dropped and would have  
  16.             // to be re-sent later.  
  17.             // Right-now we don't have the ability to do this.  
  18.             ALOGW("EventThread: dropping event (%08x) for connection %p",  
  19.                     event.header.type, conn.get());  
  20.         } else if (err < 0) {  
  21.             // handle any other error on the pipe as fatal. the only  
  22.             // reasonable thing to do is to clean-up this connection.  
  23.             // The most common error we'll get here is -EPIPE.  
  24.             removeDisplayEventConnection(signalConnections[i]);  
  25.         }  
  26.     }  
  27.     return true;  
  28. }  

我們再來看下waitForEvent函式中下面程式碼段，timestamp為0表示沒有時間，waitForSync為true表示至少有一個客戶和EventThread建立了連線。這段程式碼一旦有客戶連線，就呼叫enableVSyncLocked接收DispSyncSource的VSync訊號。如果在接受訊號中，所有客戶都斷開了連線，則呼叫disableVSyncLocked函式停止接受DispSyncSource物件的訊號。

[cpp] view plain copy
  1. // Here we figure out if we need to enable or disable vsyncs  
  2. if (timestamp && !waitForVSync) {  
  3.     // we received a VSYNC but we have no clients  
  4.     // don't report it, and disable VSYNC events  
  5.     disableVSyncLocked();  
  6. } else if (!timestamp && waitForVSync) {  
  7.     // we have at least one client, so we want vsync enabled  
  8.     // (TODO: this function is called right after we finish  
  9.     // notifying clients of a vsync, so this call will be made  
  10.     // at the vsync rate, e.g. 60fps.  If we can accurately  
  11.     // track the current state we could avoid making this call  
  12.     // so often.)  
  13.     enableVSyncLocked();  
  14. }  

我們先來看下enableVSyncLocked函式

[cpp] view plain copy
  1. void EventThread::enableVSyncLocked() {  
  2.     if (!mUseSoftwareVSync) {  
  3.         // never enable h/w VSYNC when screen is off  
  4.         if (!mVsyncEnabled) {  
  5.             mVsyncEnabled = true;  
  6.             mVSyncSource->setCallback(static_cast<VSyncSource::Callback*>(this));  
  7.             mVSyncSource->setVSyncEnabled(true);  
  8.         }  
  9.     }  
  10.     mDebugVsyncEnabled = true;  
  11.     sendVsyncHintOnLocked();  
  12. }  

我們先來看看mVSyncSource->setCallback函式。先要知道這個mVSyncSource是在SurfaceFlinger的init函式中。

[cpp] view plain copy
  1. sp<VSyncSource> vsyncSrc = new DispSyncSource(&mPrimaryDispSync,  
  2.         vsyncPhaseOffsetNs, true, "app");  
  3. mEventThread = new EventThread(vsyncSrc);  
  4. sp<VSyncSource> sfVsyncSrc = new DispSyncSource(&mPrimaryDispSync,  
  5.         sfVsyncPhaseOffsetNs, true, "sf");  
  6. mSFEventThread = new EventThread(sfVsyncSrc);  
  7. mEventQueue.setEventThread(mSFEventThread);  

看到上面這段程式碼，我們知道這個mVsyncSource是DispSyncSource類，我們先來看起setCallback函式，就是把callback儲存起來

[cpp] view plain copy
  1. virtual void setCallback(const sp<VSyncSource::Callback>& callback) {  
  2.     Mutex::Autolock lock(mCallbackMutex);  
  3.     mCallback = callback;  
  4. }  

再來看setVSyncEnabled函式，這裡引數enable是true，就是呼叫了DispSync的addEventListenter。這裡就回到了上一小節了，這裡我們就在DispSync中註冊了回撥了

[cpp] view plain copy
  1. virtual void setVSyncEnabled(bool enable) {  
  2.     Mutex::Autolock lock(mVsyncMutex);  
  3.     if (enable) {  
  4.         status_t err = mDispSync->addEventListener(mPhaseOffset,  
  5.                 static_cast<DispSync::Callback*>(this));  
  6.         if (err != NO_ERROR) {  
  7.             ALOGE("error registering vsync callback: %s (%d)",  
  8.                     strerror(-err), err);  
  9.         }  
  10.         //ATRACE_INT(mVsyncOnLabel.string(), 1);  
  11.     } else {  
  12.         status_t err = mDispSync->removeEventListener(  
  13.                 static_cast<DispSync::Callback*>(this));  
  14.         if (err != NO_ERROR) {  
  15.             ALOGE("error unregistering vsync callback: %s (%d)",  
  16.                     strerror(-err), err);  
  17.         }  
  18.         //ATRACE_INT(mVsyncOnLabel.string(), 0);  
  19.     }  
  20.     mEnabled = enable;  
  21. }  

這樣回想上一節在fireCallbackInvocations中遍歷所有的回撥時，就呼叫了DispSyncSource類的onDispSyncEvent函式，而這個函式主要是呼叫了其成員變數mCallback的onVSyncEvent，這個mCallback就是之前在EventThread中的waitForEvent註冊的，就是EventThread自己。

[cpp] view plain copy
  1. virtual void onDispSyncEvent(nsecs_t when) {  
  2.     sp<VSyncSource::Callback> callback;  
  3.     {  
  4.         Mutex::Autolock lock(mCallbackMutex);  
  5.         callback = mCallback;  
  6.   
  7.         if (mTraceVsync) {  
  8.             mValue = (mValue + 1) % 2;  
  9.             ATRACE_INT(mVsyncEventLabel.string(), mValue);  
  10.         }  
  11.     }  
  12.   
  13.     if (callback != NULL) {  
  14.         callback->onVSyncEvent(when);  
  15.     }  
  16. }  

因此最後到了EventThread的onVsyncEvent函式，這個函式把資料放在mVSyncEvent陣列第一個，然後呼叫了Condition的broadcast函式。

[cpp] view plain copy
  1. void EventThread::onVSyncEvent(nsecs_t timestamp) {  
  2.     Mutex::Autolock _l(mLock);  
  3.     mVSyncEvent[0].header.type = DisplayEventReceiver::DISPLAY_EVENT_VSYNC;  
  4.     mVSyncEvent[0].header.id = 0;  
  5.     mVSyncEvent[0].header.timestamp = timestamp;  
  6.     mVSyncEvent[0].vsync.count++;  
  7.     mCondition.broadcast();  
  8. }  

最後之前在EventThread的threadLoop函式中呼叫waitForEvent會阻塞，當這裡呼叫Condition的broadcast之後，waitForEvent就喚醒，並且得到了mVsynEvent中的資料。緊接著就是在EventThread中的threadLoop呼叫conn->postEvent來傳送Event。這裡是通過BitTube物件中的socket傳送到MessageQueue中。這個我們在第二節中分析過了。


4.3 MessageQueue分發VSync訊號

我們來回顧下，在MessageQueue中有下面這個函式。這樣當EventThread通過BitTube傳送資料的話，pollOnce會喚醒epoll_wait然後就到這個cb_eventReceiver這個回撥函式

[cpp] view plain copy
  1. void MessageQueue::setEventThread(const sp<EventThread>& eventThread)  
  2. {  
  3.     mEventThread = eventThread;  
  4.     mEvents = eventThread->createEventConnection();  
  5.     mEventTube = mEvents->getDataChannel();  
  6.     mLooper->addFd(mEventTube->getFd(), 0, Looper::EVENT_INPUT,  
  7.             MessageQueue::cb_eventReceiver, this);  
  8. }  

cb_eventReceiver就是呼叫了eventReceiver函式。

[cpp] view plain copy
  1. int MessageQueue::cb_eventReceiver(int fd, int events, void* data) {  
  2.     MessageQueue* queue = reinterpret_cast<MessageQueue *>(data);  
  3.     return queue->eventReceiver(fd, events);  
  4. }  
  5.   
  6. int MessageQueue::eventReceiver(int /*fd*/, int /*events*/) {  
  7.     ssize_t n;  
  8.     DisplayEventReceiver::Event buffer[8];  
  9.     while ((n = DisplayEventReceiver::getEvents(mEventTube, buffer, 8)) > 0) {  
  10.         for (int i=0 ; i<n ; i++) {  
  11.             if (buffer[i].header.type == DisplayEventReceiver::DISPLAY_EVENT_VSYNC) {  
  12. #if INVALIDATE_ON_VSYNC  
  13.                 mHandler->dispatchInvalidate();  
  14. #else  
  15.                 mHandler->dispatchRefresh();  
  16. #endif  
  17.                 break;  
  18.             }  
  19.         }  
  20.     }  
  21.     return 1;  
  22. }  

這裡我們支援VSync訊號就會呼叫mHandler的dispatchRefresh函式。

[cpp] view plain copy
  1. void MessageQueue::Handler::dispatchRefresh() {  
  2.     if ((android_atomic_or(eventMaskRefresh, &mEventMask) & eventMaskRefresh) == 0) {  
  3.         mQueue.mLooper->sendMessage(this, Message(MessageQueue::REFRESH));  
  4.     }  
  5. }  

而在Hander的處理中，最終是呼叫了SurfaceFlinger的onMessageReceived函式

[cpp] view plain copy
  1. case REFRESH:  
  2.     android_atomic_and(~eventMaskRefresh, &mEventMask);  
  3.     mQueue.mFlinger->onMessageReceived(message.what);  
  4.     break;  

而在SurfaceFlinger的onMessageReceived函式最終會呼叫了handleMessageRefresh函式。

[cpp] view plain copy
  1. void SurfaceFlinger::onMessageReceived(int32_t what) {  
  2.     ATRACE_CALL();  
  3.     switch (what) {  
  4.         ......  
  5.         case MessageQueue::REFRESH: {  
  6.             handleMessageRefresh();  
  7.             break;  
  8.         }  
  9.     }  
  10. }  

handleMessageRefresh函式負責重新整理系統的顯示。這樣我們就分析了從底層傳送VSync訊號最終到達SurfaceFlinger的handleMessageRefresh函式。


4.4 VSync訊號分發總結

我們回顧下整個流程，VSync訊號從底層產生後，經過幾個函式，儲存到了SurfaceFlinger的mPrimaryDispSync變數（DisySync類）的陣列中，這樣設計的目的讓底層的呼叫盡快結束，否則會耽擱下次VSync訊號的傳送。然後在mPrimaryDispSync變數關聯的執行緒開始分發陣列中的VSync訊號，分發的過程也呼叫了幾個回撥函式，最終結果是放在EventThread物件的陣列中。EventThread是轉發VSync訊號的中心。不但會把VSync訊號發給SurfaceFlinger，還會把訊號傳送到使用者程式中去。EventThread的工作比較重，因此SurfaceFlinger中使用了兩個EventThread物件來轉發VSync訊號。確保能及時轉發。SurfaceFlinger中的MessageQueue收到Event後，會將Event轉化成訊息傳送，這樣最終就能在主執行緒呼叫SurfaceFlinger的函式處理VSync訊號了。

相關文章