在HWUI渲染完成后,Buffer会在frameworks/native/libs/gui/BufferQueueProducer.cpp
中通过queueBuffer放入BufferQueue,在该函数中调用frameAvailableListener->onFrameAvailable(item)
通知consumer消费者,从而触发SurfaceFlinger合成。
onFrameAvailable触发合成
上面的frameAvailableListener对象类型是sp<IConsumerListener> frameAvailableListener;
参考Android 图形显示框架 中的《Surface创建流程》,在该流程中会创建BufferQueue,调用BufferQueue::createBufferQueue
函数。
而class ProxyConsumerListener : public BnConsumerListener...
是IConsumerListener接口的Bn端,所以会调用到下面代码:
BufferQueue中的frameAvailableListener,是一个IConsumerListener的接口,对应的Binder的Bn端实现为ProxyConsumerListener。
frameworks/native/libs/gui/BufferQueue.cpp 1 2 3 4 5 6 7 8 9 10 wp<ConsumerListener> mConsumerListener; void BufferQueue::ProxyConsumerListener::onFrameAvailable( const BufferItem& item) { sp<ConsumerListener> listener (mConsumerListener.promote()) ; if (listener != nullptr ) { listener->onFrameAvailable(item); } }
在ConsumerBase.h中该类继承ConsumerListener。所以此处的mConsumerListener是ConsumerBase中的实现。
frameworks/native/libs/gui/include/gui/ConsumerBase.h 1 2 class ConsumerBase : public virtual RefBase, protected ConsumerListener {...}
frameworks/native/libs/gui/ConsumerBase.cpp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 void ConsumerBase::onFrameAvailable (const BufferItem& item) { CB_LOGV("onFrameAvailable" ); sp<FrameAvailableListener> listener; { Mutex::Autolock lock (mFrameAvailableMutex) ; listener = mFrameAvailableListener.promote(); } if (listener != nullptr ) { CB_LOGV("actually calling onFrameAvailable" ); listener->onFrameAvailable(item); } }
在BufferQueueLayer中,class BufferQueueLayer : public BufferLayer, public BufferLayerConsumer::ContentsChangedListener{......}
。
而class BufferLayerConsumer : public ConsumerBase...
frameworks/native/services/surfaceflinger/BufferQueueLayer.cpp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 void BufferQueueLayer::onFrameAvailable (const BufferItem& item) { ATRACE_CALL(); { if (mFlinger->mUseSmart90ForVideo) { const nsecs_t presentTime = item.mIsAutoTimestamp ? 0 : item.mTimestamp; mFlinger->mScheduler->addLayerPresentTimeAndHDR(mSchedulerLayerHandle, presentTime, item.mHdrMetadata.validTypes != 0 ); } Mutex::Autolock lock (mQueueItemLock) ; if (item.mFrameNumber == 1 ) { mLastFrameNumberReceived = 0 ; } while (item.mFrameNumber != mLastFrameNumberReceived + 1 ) { status_t result = mQueueItemCondition.waitRelative(mQueueItemLock, ms2ns(500 )); if (result != NO_ERROR) { ALOGE("[%s] Timed out waiting on callback" , mName.string ()); } } mQueueItems.push_back(item); mQueuedFrames++; mLastFrameNumberReceived = item.mFrameNumber; mQueueItemCondition.broadcast(); } mFlinger->mInterceptor->saveBufferUpdate(this , item.mGraphicBuffer->getWidth(), item.mGraphicBuffer->getHeight(), item.mFrameNumber); if (isRemovedFromCurrentState()) { fakeVsync(); } else { mFlinger->signalLayerUpdate(); } mConsumer->onBufferAvailable(item); }
类图
BufferQueueLayer有专门的Consumer,即BufferLayerConsumer。BufferLayerConsumer继承ConsumerBase。ConsumerBase通过IGraphicBufferConsumer和BufferQueue进行通信。
BufferQueue中的frameAvailableListener,是一个IConsumerListener的接口,对应的Binder的Bn端实现为ProxyConsumerListener
。
BufferQueueLayer实现了ContentsChangedListener,ContentsChangedListener继承FrameAvailableListener。BufferQueueLayer的Listener实现,被传给了ConsumerBase。
ConsumerBase实现ConsumerListener接口,构建ConsumerBase时,会创建ProxyConsumerListener
,将ConsumerBase实现的Listener接口传给ProxyConsumerListener。
BufferQueue中Listener回调时,会回调到ConsumerBase中。ConsumerBase中再通过BufferQueueLayer实现的,传下来的Listener回调到BufferLayer中。
MessageQueue消息队列
Android的消息处理机制请参考:Android Handler消息循环处理机制(例ActivityThread)
在SurfaceFlinger模块有单独的MessageQueue处理流程。在SF创建的时候,构造函数会创建meventqueue
对象。在其onFirstRef函数中调用mEventQueue->init(this);
进行初始化。
MessageQueue初始化时,创建了一个Looper和Handler。
frameworks/native/services/surfaceflinger/Scheduler/MessageQueue.cpp 1 2 3 4 5 void MessageQueue::init (const sp<SurfaceFlinger>& flinger) { mFlinger = flinger; mLooper = new Looper(true ); mHandler = new Handler(*this ); }
setEventThread变更 在Android Q中,EventThread的setEventThread
操作具体在SurfaceFlinger::enableVSyncInjections
中进行。
而非之前的是在SurfaceFlinger的init初始化函数中。
SF.cpp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 std ::unique_ptr <MessageQueue> mEventQueue;status_t SurfaceFlinger::enableVSyncInjections (bool enable) { postMessageSync(new LambdaMessage([&] { ...... if (enable) { ALOGV("VSync Injections enabled" ); if (mVSyncInjector.get() == nullptr ) { mVSyncInjector = std ::make_unique<InjectVSyncSource>(); mInjectorEventThread = std ::make_unique< impl::EventThread>(mVSyncInjector.get(), impl::EventThread::InterceptVSyncsCallback(), "injEventThread" ); } mEventQueue->setEventThread(mInjectorEventThread.get(), std ::move(resyncCallback)); } else { ALOGV("VSync Injections disabled" ); mEventQueue->setEventThread(mScheduler->getEventThread(mSfConnectionHandle), std ::move(resyncCallback)); } mInjectVSyncs = enable; })); return NO_ERROR; }
setEventThread函数做了两件事:
创建一个BitTube对象mEventTube
创建一个EventConnection
frameworks/native/services/surfaceflinger/Scheduler/MessageQueue.cpp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 gui::BitTube mEventTube; void MessageQueue::setEventThread (android::EventThread* eventThread, ResyncCallback resyncCallback) { if (mEventThread == eventThread) { return ; } if (mEventTube.getFd() >= 0 ) { mLooper->removeFd(mEventTube.getFd()); } mEventThread = eventThread; mEvents = eventThread->createEventConnection(std ::move(resyncCallback)); mEvents->stealReceiveChannel(&mEventTube); mLooper->addFd(mEventTube.getFd(), 0 , Looper::EVENT_INPUT, MessageQueue::cb_eventReceiver, this ); } int MessageQueue::cb_eventReceiver (int fd, int events, void * data) { MessageQueue* queue = reinterpret_cast <MessageQueue*>(data); return queue ->eventReceiver(fd, events); }
frameworks/native/services/surfaceflinger/Scheduler/EventThread.cpp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 sp<EventThreadConnection> EventThread::createEventConnection (ResyncCallback resyncCallback) const { return new EventThreadConnection(const_cast <EventThread*>(this ), std ::move(resyncCallback)); } void EventThreadConnection::onFirstRef () { mEventThread->registerDisplayEventConnection(this ); } status_t EventThread::registerDisplayEventConnection (const sp<EventThreadConnection>& connection) { std ::lock_guard<std ::mutex> lock (mMutex) ; auto it = std ::find(mDisplayEventConnections.cbegin(), mDisplayEventConnections.cend(), connection); if (it != mDisplayEventConnections.cend()) { ALOGW("DisplayEventConnection %p already exists" , connection.get()); mCondition.notify_all(); return ALREADY_EXISTS; } mDisplayEventConnections.push_back(connection); mCondition.notify_all(); return NO_ERROR; }
创建BitTube对象,构造函数会调用init函数:
frameworks/native/libs/gui/BitTube.cpp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 static const size_t DEFAULT_SOCKET_BUFFER_SIZE = 4 * 1024 ;BitTube::BitTube(size_t bufsize) { init(bufsize, bufsize); } void BitTube::init (size_t rcvbuf, size_t sndbuf) { int sockets[2 ]; if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0 , sockets) == 0 ) { size_t size = DEFAULT_SOCKET_BUFFER_SIZE; setsockopt(sockets[0 ], SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof (rcvbuf)); setsockopt(sockets[1 ], SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof (sndbuf)); setsockopt(sockets[0 ], SOL_SOCKET, SO_SNDBUF, &size, sizeof (size)); setsockopt(sockets[1 ], SOL_SOCKET, SO_RCVBUF, &size, sizeof (size)); fcntl(sockets[0 ], F_SETFL, O_NONBLOCK); fcntl(sockets[1 ], F_SETFL, O_NONBLOCK); mReceiveFd.reset(sockets[0 ]); mSendFd.reset(sockets[1 ]); } else { mReceiveFd.reset(); ALOGE("BitTube: pipe creation failed (%s)" , strerror(errno)); } } int BitTube::getFd () const { return mReceiveFd; }
signalLayerUpdate通知Layer更新信息 接着上面第一部分的流程,触发SF的合成从signalLayerUpdate开始。
SF.cpp 1 2 3 4 void SurfaceFlinger::signalLayerUpdate () { mScheduler->resetIdleTimer(); mEventQueue->invalidate(); }
调用到MessageQueue的invalidate函数。
frameworks/native/services/surfaceflinger/Scheduler/MessageQueue.cpp 1 2 3 void MessageQueue::invalidate () { mEvents->requestNextVsync(); }
请求下一个Vsync(垂直同步机制),主要作用是通知Vsync机制在下一个SF的Vsync到来的时候唤醒SF进行工作,从而进行合成处理。
frameworks/native/services/surfaceflinger/Scheduler/EventThread.cpp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 void EventThreadConnection::requestNextVsync () { ATRACE_NAME("requestNextVsync" ); mEventThread->requestNextVsync(this ); } void EventThread::requestNextVsync (const sp<EventThreadConnection>& connection) { if (connection->resyncCallback) { connection->resyncCallback(); } std ::lock_guard<std ::mutex> lock (mMutex) ; if (connection->vsyncRequest == VSyncRequest::None) { connection->vsyncRequest = VSyncRequest::Single; mCondition.notify_all(); } } enum class VSyncRequest { None = -1 , Single = 0 , Periodic = 1 , };
然后会触发threadmain函数,这个和Android P上的threadloop流程是不同的。
frameworks/native/services/surfaceflinger/Scheduler/EventThread.cpp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 void EventThread::threadMain (std ::unique_lock<std ::mutex>& lock) { DisplayEventConsumers consumers; while (mState != State::Quit) { std ::optional<DisplayEventReceiver::Event> event; if (!mPendingEvents.empty()) { event = mPendingEvents.front(); mPendingEvents.pop_front(); switch (event->header.type) { case DisplayEventReceiver::DISPLAY_EVENT_HOTPLUG: if (event->hotplug.connected && !mVSyncState) { mVSyncState.emplace(event->header.displayId); } else if (!event->hotplug.connected && mVSyncState && mVSyncState->displayId == event->header.displayId) { mVSyncState.reset(); } break ; case DisplayEventReceiver::DISPLAY_EVENT_VSYNC: if (mInterceptVSyncsCallback) { mInterceptVSyncsCallback(event->header.timestamp); } break ; } } bool vsyncRequested = false ; auto it = mDisplayEventConnections.begin(); while (it != mDisplayEventConnections.end()) { if (const auto connection = it->promote()) { vsyncRequested |= connection->vsyncRequest != VSyncRequest::None; if (event && shouldConsumeEvent(*event, connection)) { consumers.push_back(connection); } ++it; } else { it = mDisplayEventConnections.erase(it); } } if (!consumers.empty()) { dispatchEvent(*event, consumers); consumers.clear(); } State nextState; if (mVSyncState && vsyncRequested) { nextState = mVSyncState->synthetic ? State::SyntheticVSync : State::VSync; } else { ALOGW_IF(!mVSyncState, "Ignoring VSYNC request while display is disconnected" ); nextState = State::Idle; } if (mState != nextState) { if (mState == State::VSync) { mVSyncSource->setVSyncEnabled(false ); } else if (nextState == State::VSync) { mVSyncSource->setVSyncEnabled(true ); } mState = nextState; } if (event) { continue ; } if (mState == State::Idle) { mCondition.wait(lock); } else { const auto timeout = mState == State::SyntheticVSync ? 16 ms : 1000 ms; if (mCondition.wait_for(lock, timeout) == std ::cv_status::timeout) { ALOGW_IF(mState == State::VSync, "Faking VSYNC due to driver stall" ); LOG_FATAL_IF(!mVSyncState); mPendingEvents.push_back(makeVSync(mVSyncState->displayId, systemTime(SYSTEM_TIME_MONOTONIC), ++mVSyncState->count)); } } } } enum class State { Idle, Quit, SyntheticVSync, VSync, };
VSYNC事件到来 将会回调onVSyncEvent:
frameworks/native/services/surfaceflinger/Scheduler/EventThread.cpp 1 2 3 4 5 6 7 void EventThread::onVSyncEvent (nsecs_t timestamp) { std ::lock_guard<std ::mutex> lock (mMutex) ; LOG_FATAL_IF(!mVSyncState); mPendingEvents.push_back(makeVSync(mVSyncState->displayId, timestamp, ++mVSyncState->count)); mCondition.notify_all(); }
Hotplug事件到来 将会回调onHotplugReceived:
frameworks/native/services/surfaceflinger/Scheduler/EventThread.cpp 1 2 3 4 5 6 void EventThread::onHotplugReceived (PhysicalDisplayId displayId, bool connected) { std ::lock_guard<std ::mutex> lock (mMutex) ; mPendingEvents.push_back(makeHotplug(displayId, systemTime(), connected)); mCondition.notify_all(); }
dispatchEvent分发事件 从上面的threadMain函数会调用dispatchEvent函数分发事件:
Connection通过postEvent将Event抛出来后,通过sendEvents将事件发出去。
frameworks/native/services/surfaceflinger/Scheduler/EventThread.cpp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 void EventThread::dispatchEvent (const DisplayEventReceiver::Event& event, const DisplayEventConsumers& consumers) { for (const auto & consumer : consumers) { switch (consumer->postEvent(event)) { case NO_ERROR: break ; case -EAGAIN: ALOGW("Failed dispatching %s for %s" , toString(event).c_str(), toString(*consumer).c_str()); break ; default : removeDisplayEventConnectionLocked(consumer); } } } status_t EventThreadConnection::postEvent (const DisplayEventReceiver::Event& event) { ssize_t size = DisplayEventReceiver::sendEvents(&mChannel, &event, 1 ); return size < 0 ? status_t (size) : status_t (NO_ERROR); }
DisplayEventReceiver中是通过BitTube将事件发出去,sendObjects注意这里的参数:
frameworks/native/libs/gui/DisplayEventReceiver.cpp 1 2 3 4 5 ssize_t DisplayEventReceiver::sendEvents (gui::BitTube* dataChannel, Event const * events, size_t count) { return gui::BitTube::sendObjects(dataChannel, events, count); }
MessageQueue处理Message SF的线程run时,有一个死循环,循环等待事件:
SF.cpp 1 2 3 4 5 6 7 8 9 void SurfaceFlinger::run () { do { waitForEvent(); } while (true ); } void SurfaceFlinger::waitForEvent () { mEventQueue->waitMessage(); }
在MessageQueue中,会有looper一直循环等待消息。
waitMessage,通过采用一个死循环,处理Looper的pollOnce。Looper内部的主要是采用epoll_wait对fd进行监听,BitTube发送Event对象后,epoll_wait结束,调用callback,处理事件。
可参考Handler文章:Android Handler消息循环处理机制
MessageQueue.cpp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 void MessageQueue::waitMessage () { do { IPCThreadState::self()->flushCommands(); int32_t ret = mLooper->pollOnce(-1 ); switch (ret) { case Looper::POLL_WAKE: case Looper::POLL_CALLBACK: continue ; case Looper::POLL_ERROR: ALOGE("Looper::POLL_ERROR" ); continue ; case Looper::POLL_TIMEOUT: continue ; default : ALOGE("Looper::pollOnce() returned unknown status %d" , ret); continue ; } } while (true ); }
MessageQueue对应的callback为cb_eventReceiver:
MessageQueue.cpp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 enum { INVALIDATE = 0 , REFRESH = 1 , }; int MessageQueue::cb_eventReceiver (int fd, int events, void * data) { MessageQueue* queue = reinterpret_cast <MessageQueue*>(data); return queue ->eventReceiver(fd, events); } int MessageQueue::eventReceiver (int , int ) { ssize_t n; DisplayEventReceiver::Event buffer[8 ]; while ((n = DisplayEventReceiver::getEvents(&mEventTube, buffer, 8 )) > 0 ) { for (int i = 0 ; i < n; i++) { if (buffer[i].header.type == DisplayEventReceiver::DISPLAY_EVENT_VSYNC) { mHandler->dispatchInvalidate(); break ; } } } return 1 ; } void MessageQueue::Handler::dispatchInvalidate() { if ((android_atomic_or(eventMaskInvalidate, &mEventMask) & eventMaskInvalidate) == 0 ) { mQueue.mLooper->sendMessage(this , Message(MessageQueue::INVALIDATE)); } }
sendMessage
在Handler.java中调用到MessageQueue.java的enqueueMessage
函数,然后调用JNI函数nativeWake,唤醒Looper.java的loop函数。
调用其中的dispatchMessage处理消息。
dispatchMessage函数会调用handleMessage函数,开始处理消息。
1 2 3 4 5 6 7 8 9 10 11 12 void MessageQueue::Handler::handleMessage(const Message& message) { switch (message.what) { case INVALIDATE: android_atomic_and(~eventMaskInvalidate, &mEventMask); mQueue.mFlinger->onMessageReceived(message.what); break ; case REFRESH: android_atomic_and(~eventMaskRefresh, &mEventMask); mQueue.mFlinger->onMessageReceived(message.what); break ; } }
onMessageReceived处理INVALIDATE消息 MessageQueue触发Handler消息处理机制,开始触发INVALIDATE消息合成。
大体分成两部分:
SF更新合成相关的信息(即handleMessageTransaction)
SF执行合成相关的操作并显示
SurfaceFlinger.cpp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 void SurfaceFlinger::onMessageReceived (int32_t what) NO_THREAD_SAFETY_ANALYSIS { ATRACE_CALL(); switch (what) { case MessageQueue::INVALIDATE: { bool frameMissed = previousFrameMissed(); bool hwcFrameMissed = mHadDeviceComposition && frameMissed; bool gpuFrameMissed = mHadClientComposition && frameMissed; ATRACE_INT("FrameMissed" , static_cast <int >(frameMissed)); ATRACE_INT("HwcFrameMissed" , static_cast <int >(hwcFrameMissed)); ATRACE_INT("GpuFrameMissed" , static_cast <int >(gpuFrameMissed)); if (frameMissed) { mFrameMissedCount++; mTimeStats->incrementMissedFrames(); } if (hwcFrameMissed) { mHwcFrameMissedCount++; } if (gpuFrameMissed) { mGpuFrameMissedCount++; } if (mUseSmart90ForVideo) { mScheduler->updateFpsBasedOnContent(); } if (performSetActiveConfig()) { break ; } if (frameMissed && mPropagateBackpressure) { if ((hwcFrameMissed && !gpuFrameMissed) || mPropagateBackpressureClientComposition) { signalLayerUpdate(); break ; } } updateVrFlinger(); bool refreshNeeded = handleMessageTransaction(); refreshNeeded |= handleMessageInvalidate(); updateCursorAsync(); updateInputFlinger(); refreshNeeded |= mRepaintEverything; if (refreshNeeded && CC_LIKELY(mBootStage != BootStage::BOOTLOADER)) { signalRefresh(); } break ; } case MessageQueue::REFRESH: { handleMessageRefresh(); break ; } } }
一、丢帧处理frameMissed 如果丢帧,则mPropagateBackpressure
为true。
该变量是在SurfaceFlinger的构造函数中,由debug.sf.disable_backpressure
属性控制。
SF.cpp 1 2 3 4 5 6 7 8 property_get("debug.sf.disable_backpressure" , value, "0" ); mPropagateBackpressure = !atoi(value); ALOGI_IF(!mPropagateBackpressure, "Disabling backpressure propagation" ); property_get("debug.sf.enable_gl_backpressure" , value, "0" ); mPropagateBackpressureClientComposition = atoi(value); ALOGI_IF(mPropagateBackpressureClientComposition, "Enabling backpressure propagation for Client Composition" );
例如我的一加六 Android Q设备:
1 2 adb shell getprop debug.sf.disable_backpressure 1
二、handleMessageTransaction处理Transaction Vsync到来后,触发INVALIDATE消息时会先处理Transition。
如上代码先调用handleMessageTransaction
。这个过程就是处理应用传过来的各种Transaction。
大致函数调用流程:
handleMessageTransaction -> handleTransaction -> handleTransactionLocked
-> (processDisplayChangesLocked) -> commitTransaction()
handleMessageTransaction主要处理Layer属性变化,显示设备变化等情况,最终将变化的信息mCurrentState提交到mDrawingState, 等待合成处理.
即最终commitTransaction
函数会有个状态更替,将mCurrentState赋值给了mDrawingState。
SF.cpp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 void SurfaceFlinger::commitTransaction () { ..... withTracingLock([&]() { mDrawingState = mCurrentState; mCurrentState.colorMatrixChanged = false ; mDrawingState.traverseInZOrder([&](Layer* layer) { layer->commitChildList(); if (mOffscreenLayers.count(layer)) { mOffscreenLayers.erase(layer); } }); commitOffscreenLayers(); }); mTransactionPending = false ; mAnimTransactionPending = false ; mTransactionCV.broadcast(); }
mCurrentState和mDrawingState
可参考:Android SurfaceFlinger和HWC2概述 - mCurrentState和mDrawingState
mCurrentState状态:准备数据,应用传过来的数据保存在mCurrentState中。
mDrawingState状态:进程合成状态,需要进行合成的数据保存在mDrawingState中。
即每次合成时,先更新一下状态数据。每一层Layer也需要去更新状态数据。
handleTransactionLocked 1. 检查mCurrentState的Layer的可见区域 该函数第一部分就是遍历mCurrentState的Layer,并检查Layer的可见区域VisableRegion是否发生变化。
如果没发生变化则不需要检查layer
如果发生变化,则对比该Layer的显示区域和原来的显示区域是否发生变化,若变化则设置mVisibleRegionsDirty为true
SF.cpp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 void SurfaceFlinger::handleTransactionLocked (uint32_t transactionFlags) { mCurrentState.traverseInZOrder([](Layer* layer) { layer->notifyAvailableFrames(); }); if ((transactionFlags & eTraversalNeeded) || mTraversalNeededMainThread) { mCurrentState.traverseInZOrder([&](Layer* layer) { uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded); if (!trFlags) return ; const uint32_t flags = layer->doTransaction(0 ); if (flags & Layer::eVisibleRegion) mVisibleRegionsDirty = true ; if (flags & Layer::eInputInfoChanged) { mInputInfoChanged = true ; } }); mTraversalNeededMainThread = false ; } ...... }
2. 检查显示设备是否变化 该函数第二部分先调用processDisplayChangesLocked
函数。
SF.cpp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 void SurfaceFlinger::handleTransactionLocked (uint32_t transactionFlags) { ...... if (transactionFlags & eDisplayTransactionNeeded) { processDisplayChangesLocked(); processDisplayHotplugEventsLocked(); } if (transactionFlags & (eDisplayLayerStackChanged|eDisplayTransactionNeeded)) { ...} ...... } void SurfaceFlinger::processDisplayChangesLocked () { const KeyedVector<wp<IBinder>, DisplayDeviceState>& curr(mCurrentState.displays); const KeyedVector<wp<IBinder>, DisplayDeviceState>& draw(mDrawingState.displays); if (!curr.isIdenticalTo(draw)) { mVisibleRegionsDirty = true ; const size_t cc = curr.size(); size_t dc = draw.size(); for (size_t i = 0 ; i < dc;) { const ssize_t j = curr.indexOfKey(draw.keyAt(i)); if (j < 0 ) { if (const auto display = getDisplayDeviceLocked(draw.keyAt(i))) { const auto displayId = display->getId(); display->disconnect(); if (!display->isVirtual()) { LOG_ALWAYS_FATAL_IF(!displayId); dispatchDisplayHotplugEvent(displayId->value, false ); } } mDisplays.erase(draw.keyAt(i)); } else { const DisplayDeviceState& state(curr[j]); const wp<IBinder>& displayToken = curr.keyAt(j); const sp<IBinder> state_binder = IInterface::asBinder(state.surface); const sp<IBinder> draw_binder = IInterface::asBinder(draw[i].surface); if (state_binder != draw_binder) { if (const auto display = getDisplayDeviceLocked(displayToken)) { display->disconnect(); } mDisplays.erase(displayToken); mDrawingState.displays.removeItemsAt(i); dc--; continue ; } if (const auto display = getDisplayDeviceLocked(displayToken)) { if (state.layerStack != draw[i].layerStack) { display->setLayerStack(state.layerStack); } if ((state.orientation != draw[i].orientation) || (state.viewport != draw[i].viewport) || (state.frame != draw[i].frame)) { display->setProjection(state.orientation, state.viewport, state.frame); } if (state.width != draw[i].width || state.height != draw[i].height) { display->setDisplaySize(state.width, state.height); } } } ++i; } for (size_t i = 0 ; i < cc; i++) { if (draw.indexOfKey(curr.keyAt(i)) < 0 ) { const DisplayDeviceState& state (curr[i]) ; sp<compositionengine::DisplaySurface> dispSurface; sp<IGraphicBufferProducer> producer; sp<IGraphicBufferProducer> bqProducer; sp<IGraphicBufferConsumer> bqConsumer; getFactory().createBufferQueue(&bqProducer, &bqConsumer, false ); std ::optional<DisplayId> displayId; if (state.isVirtual()) { ...... } else { ALOGE_IF(state.surface != nullptr , "adding a supported display, but rendering " "surface is provided (%p), ignoring it" , state.surface.get()); displayId = state.displayId; LOG_ALWAYS_FATAL_IF(!displayId); dispSurface = new FramebufferSurface(getHwComposer(), *displayId, bqConsumer); producer = bqProducer; } const wp<IBinder>& displayToken = curr.keyAt(i); if (dispSurface != nullptr ) { mDisplays.emplace(displayToken, setupNewDisplayDeviceInternal(displayToken, displayId, state, dispSurface, producer)); if (!state.isVirtual()) { LOG_ALWAYS_FATAL_IF(!displayId); dispatchDisplayHotplugEvent(displayId->value, true ); } } } } } mDrawingState.displays = mCurrentState.displays; }
第三部分:继续执行handleTransactionLocked
函数,更新transform hint相关信息
4. 更新Layer信息 第四部分:更新Layer信息
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 void SurfaceFlinger::handleTransactionLocked (uint32_t transactionFlags) { ...... if (transactionFlags & (eDisplayLayerStackChanged|eDisplayTransactionNeeded)) { ...... mCurrentState.traverseInZOrder([&](Layer* layer) { ... if (!hintDisplay) { hintDisplay = getDefaultDisplayDeviceLocked(); } if (hintDisplay) { layer->updateTransformHint(hintDisplay); } first = false ; }); } if (mLayersAdded) { mLayersAdded = false ; mVisibleRegionsDirty = true ; } if (mLayersRemoved) { mLayersRemoved = false ; mVisibleRegionsDirty = true ; mDrawingState.traverseInZOrder([&](Layer* layer) { if (mLayersPendingRemoval.indexOf(layer) >= 0 ) { Region visibleReg; visibleReg.set (layer->getScreenBounds()); invalidateLayerStack(layer, visibleReg); } }); } commitInputWindowCommands(); commitTransaction(); } }
5. 信息更新完成,mCurrentState提交到mDrawingState 执行到commitTransaction函数就代表所有Layer信息更新完成,下一步开始合成显示这些变化后的内容(mDrawingState)
三、handleMessageInvalidate SF.cpp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 bool SurfaceFlinger::handleMessageInvalidate () { ATRACE_CALL(); bool refreshNeeded = handlePageFlip(); ...... for (auto & layer : mLayersPendingRefresh) { Region visibleReg; visibleReg.set (layer->getScreenBounds()); invalidateLayerStack(layer, visibleReg); } mLayersPendingRefresh.clear(); return refreshNeeded; } void SurfaceFlinger::invalidateLayerStack (const sp<const Layer>& layer, const Region& dirty) { for (const auto & [token, displayDevice] : mDisplays) { auto display = displayDevice->getCompositionDisplay(); if (display->belongsInOutput(layer->getLayerStack(), layer->getPrimaryDisplayOnly())) { display->editState().dirtyRegion.orSelf(dirty); } } }
handlePageFlip mLayersWithQueuedFrames用于标记有Frame的Layer,详细处理查看上面对BufferQueueLayer::onFrameAvailable
函数的注解。
SF.cpp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 bool SurfaceFlinger::handlePageFlip () { ATRACE_CALL(); ALOGV("handlePageFlip" ); nsecs_t latchTime = systemTime(); bool visibleRegions = false ; bool frameQueued = false ; bool newDataLatched = false ; mDrawingState.traverseInZOrder([&](Layer* layer) { if (layer->hasReadyFrame()) { frameQueued = true ; nsecs_t expectedPresentTime; expectedPresentTime = mScheduler->expectedPresentTime(); if (layer->shouldPresentNow(expectedPresentTime)) { mLayersWithQueuedFrames.push_back(layer); } else { ATRACE_NAME("!layer->shouldPresentNow()" ); layer->useEmptyDamage(); } } else { layer->useEmptyDamage(); } }); if (!mLayersWithQueuedFrames.empty()) { Mutex::Autolock lock (mStateLock) ; for (auto & layer : mLayersWithQueuedFrames) { if (layer->latchBuffer(visibleRegions, latchTime)) { mLayersPendingRefresh.push_back(layer); } layer->useSurfaceDamage(); if (layer->isBufferLatched()) { newDataLatched = true ; } } } mVisibleRegionsDirty |= visibleRegions; if (frameQueued && (mLayersWithQueuedFrames.empty() || !newDataLatched)) { signalLayerUpdate(); } if (CC_UNLIKELY(mBootStage == BootStage::BOOTLOADER && newDataLatched)) { ALOGI("Enter boot animation" ); mBootStage = BootStage::BOOTANIMATION; } return !mLayersWithQueuedFrames.empty() && newDataLatched; }
Note: 注意,所有的mLayersWithQueuedFrames都会走上面和下面的流程,每个Layer有自己的BufferLayerConsumer和BufferQueue。
latchBuffer->updateTexImage->acquireBuffer
详细流程可参考:Android 图形显示框架之BufferQueue-acquire&release
该函数中调用updateTexImage
,而这个关键函数回去获取Buffer。
拿到Buffer后,将Buffer保存在mSlots[slot].mGraphicBuffer
中。同时更新mFrameNumber和mFence。
该函数updateTexImage
有几种返回处理结果:
frameworks/native/services/surfaceflinger/BufferQueueLayer.cpp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 status_t BufferQueueLayer::updateTexImage (bool & recomputeVisibleRegions, nsecs_t latchTime) { ... status_t updateResult = mConsumer->updateTexImage(&r, expectedPresentTime, &mAutoRefresh, &queuedBuffer, maxFrameNumberToAcquire); if (updateResult == BufferQueue::PRESENT_LATER) { mFlinger->signalLayerUpdate(); return BAD_VALUE; } else if (updateResult == BufferLayerConsumer::BUFFER_REJECTED) { if (queuedBuffer) { Mutex::Autolock lock(mQueueItemLock); mFlinger->mTimeStats->removeTimeRecord(layerID, mQueueItems[0 ].mFrameNumber); mQueueItems.removeAt(0 ); mQueuedFrames--; } return BAD_VALUE; } else if (updateResult != NO_ERROR || mUpdateTexImageFailed) { ... } }
调用BufferLayerConsumer的updateTexImage,在acquireBufferLocked请求Buffer后,释放上一个Buffer,更新Buffer
frameworks/native/services/surfaceflinger/BufferLayerConsumer.cpp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 status_t BufferLayerConsumer::updateTexImage (BufferRejecter* rejecter, nsecs_t expectedPresentTime, bool * autoRefresh, bool * queuedBuffer, uint64_t maxFrameNumber) { status_t err = acquireBufferLocked(&item, expectedPresentTime, maxFrameNumber); ...... err = updateAndReleaseLocked(item, &mPendingRelease); ... } status_t BufferLayerConsumer::updateAndReleaseLocked (const BufferItem& item, PendingRelease* pendingRelease) { int slot = item.mSlot; ...... if (mCurrentTexture != BufferQueue::INVALID_BUFFER_SLOT) { if (pendingRelease == nullptr ) { status_t status = releaseBufferLocked(mCurrentTexture, mCurrentTextureBuffer->graphicBuffer()); if (status < NO_ERROR) { BLC_LOGE("updateAndRelease: failed to release buffer: %s (%d)" , strerror(-status), status); err = status; } } else { pendingRelease->currentTexture = mCurrentTexture; pendingRelease->graphicBuffer = mCurrentTextureBuffer->graphicBuffer(); pendingRelease->isPending = true ; } } mCurrentTexture = slot; mCurrentTextureBuffer = nextTextureBuffer; mCurrentCrop = item.mCrop; mCurrentTransform = item.mTransform; mCurrentScalingMode = item.mScalingMode; mCurrentTimestamp = item.mTimestamp; mCurrentDataSpace = static_cast <ui::Dataspace>(item.mDataSpace); mCurrentHdrMetadata = item.mHdrMetadata; mCurrentFence = item.mFence; mCurrentFenceTime = item.mFenceTime; mCurrentFrameNumber = item.mFrameNumber; mCurrentTransformToDisplayInverse = item.mTransformToDisplayInverse; mCurrentSurfaceDamage = item.mSurfaceDamage; mCurrentApi = item.mApi; computeCurrentTransformMatrixLocked(); return err;
然后将通过消费者acquireBufferLocked
函数请求Buffer。
frameworks/native/libs/gui/ConsumerBase.cpp 1 2 3 4 5 6 7 8 9 10 11 status_t ConsumerBase::acquireBufferLocked (BufferItem *item, nsecs_t presentWhen, uint64_t maxFrameNumber) { if (mAbandoned) { CB_LOGE("acquireBufferLocked: ConsumerBase is abandoned!" ); return NO_INIT; } status_t err = mConsumer->acquireBuffer(item, presentWhen, maxFrameNumber); ... return OK; }
四、Invalidate流程小结(正式合成刷新前的准备工作) SF.cpp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 void SurfaceFlinger::onMessageReceived (int32_t what) NO_THREAD_SAFETY_ANALYSIS { ATRACE_CALL(); switch (what) { case MessageQueue::INVALIDATE: { ...... bool refreshNeeded = handleMessageTransaction(); refreshNeeded |= handleMessageInvalidate(); updateCursorAsync(); updateInputFlinger(); refreshNeeded |= mRepaintEverything; if (refreshNeeded && CC_LIKELY(mBootStage != BootStage::BOOTLOADER)) { signalRefresh(); } break ; } case MessageQueue::REFRESH: { handleMessageRefresh(); break ; } } }
上面的分析就是INVALIDATE的基本流程,该过程主要处理SurfaceFlinger距上次合成后的一些变化信息:
handleMessageTransaction处理Layer属性变化、显示设备变化、更新显示设备的transform hint信息、处理Layer移除和增加等相关的信息等情况,将变化信息mCurrentState提交到mDrawingState,等待合成处理
handleMessageInvalidate更新了Layer的Buffer内容(通过LatchBuffer函数从BufferQueue中获取)到Layer的纹理
mRepaintEverything表示HWC硬件要求强制刷新
参考文章