SurfaceFlinger合成一

一、Producer生产完GraphicBuffer，会通知SurfaceFlinger进行合成逻辑。

BuffeQueueProducer 中queueBuffer在完成GraphicBuffer相关操作后，会通知到SurfaceFlinger去执行合成逻辑。下来看下具体过程
继承关系：

sf12.png

时序图：

sf11.png

1、先来看第一步，为什么是执行ProxyConsumerListener中的onFrameAvailable。(注意继承关系)

我们知道在BufferQueueProducer的queueBuffer方法中。

status_t BufferQueueProducer::queueBuffer(int slot,
        const QueueBufferInput &input, QueueBufferOutput *output) {
 sp<IConsumerListener> frameAvailableListener;
......
 frameAvailableListener->onFrameAvailable(item);
......
}

frameAvailableListener->onFrameAvailable(item) 把BufferItem通知下去。
这个frameAvailableListener是什么？
frameAvailableListener = mCore->mConsumerListener;
那mCore中的mConsumerListener又是谁赋的值，
可以看到在BufferQueueConsumer中的connect方法里面

/frameworks/native/libs/gui/BufferQueueConsumer.cpp
status_t BufferQueueConsumer::connect(
        const sp<IConsumerListener>& consumerListener, bool controlledByApp) {
    ATRACE_CALL();
    if (consumerListener == nullptr) {
        BQ_LOGE("connect: consumerListener may not be NULL");
        return BAD_VALUE;
    }
  ...
    mCore->mConsumerListener = consumerListener; //@1
 ...
    return NO_ERROR;
}

在@1处进行了赋值。
那connect方法中的consumerListener又是谁，

/frameworks/native/libs/gui/include/gui/BufferQueueConsumer.h
    virtual status_t consumerConnect(const sp<IConsumerListener>& consumer,
            bool controlledByApp) {
        return connect(consumer, controlledByApp);
}

consumerConnect方法，其会调用connect,传入consumer。
那consumerConnect哪块调用，在ConsumerBase的构造方法里面有

ConsumerBase::ConsumerBase(const sp<IGraphicBufferConsumer>& bufferQueue, bool controlledByApp) :
        mAbandoned(false),
        mConsumer(bufferQueue),
        mPrevFinalReleaseFence(Fence::NO_FENCE) {
    // Choose a name using the PID and a process-unique ID.
    mName = String8::format("unnamed-%d-%d", getpid(), createProcessUniqueId());

    // Note that we can't create an sp<...>(this) in a ctor that will not keep a
    // reference once the ctor ends, as that would cause the refcount of 'this'
    // dropping to 0 at the end of the ctor.  Since all we need is a wp<...>
    // that's what we create.
    wp<ConsumerListener> listener = static_cast<ConsumerListener*>(this);
    sp<IConsumerListener> proxy = new BufferQueue::ProxyConsumerListener(listener);

    status_t err = mConsumer->consumerConnect(proxy, controlledByApp);
    if (err != NO_ERROR) {
        CB_LOGE("ConsumerBase: error connecting to BufferQueue: %s (%d)",
                strerror(-err), err);
    } else {
        mConsumer->setConsumerName(mName);
    }
}

可以看到proxy就是源头。我们从后再往前回顾一下，发现这个listener 就是BufferQueueConsumer和BufferQueue的一个连接。
那第一步就是回调ProxyConsumerListener的 onFrameAvailable。

/frameworks/native/libs/gui/BufferQueue.cpp
void BufferQueue::ProxyConsumerListener::onFrameAvailable(
        const BufferItem& item) {
    sp<ConsumerListener> listener(mConsumerListener.promote());
    if (listener != nullptr) {
        listener->onFrameAvailable(item);
    }
}

####2、第二步执行的是ConsumerBase中的onFrameAvailable方法，
上一步在ConsumerBase构造方法中我们也看到
 wp<ConsumerListener> listener = static_cast<ConsumerListener*>(this);
 sp<IConsumerListener> proxy = new BufferQueue::ProxyConsumerListener(listener);

/frameworks/native/libs/gui/BufferQueue.cpp
BufferQueue::ProxyConsumerListener::ProxyConsumerListener(
        const wp<ConsumerListener>& consumerListener):
        mConsumerListener(consumerListener) {}

/frameworks/native/libs/gui/BufferQueue.cpp
void BufferQueue::ProxyConsumerListener::onFrameAvailable(
        const BufferItem& item) {
    sp<ConsumerListener> listener(mConsumerListener.promote());
    if (listener != nullptr) {
        listener->onFrameAvailable(item);//@1
    }
}

ProxyConsumerListener构造方法中传入的就是 ConsumerBase，所以@1处的listener就是ConsumerBase

3、第三步执行ContentsChangedListener

/frameworks/native/libs/gui/ConsumerBase.cpp
void ConsumerBase::onFrameAvailable(const BufferItem& item) {
    sp<FrameAvailableListener> listener;
    { // scope for the lock
        Mutex::Autolock lock(mFrameAvailableMutex);
        listener = mFrameAvailableListener.promote();
    }

    if (listener != nullptr) {
        CB_LOGV("actually calling onFrameAvailable");
        listener->onFrameAvailable(item);
    }
}

在ConsumerBase的onFrameAvailable方法中，会调用 listener->onFrameAvailable(item);
那这个listener是谁呢，

/frameworks/native/libs/gui/ConsumerBase.cpp
void ConsumerBase::setFrameAvailableListener(
        const wp<FrameAvailableListener>& listener) {
    CB_LOGV("setFrameAvailableListener");
    Mutex::Autolock lock(mFrameAvailableMutex);
    mFrameAvailableListener = listener;
}

setFrameAvailableListener的调用者在BufferLayerConsumer中的setContentsChangedListene中，

/frameworks/native/services/surfaceflinger/BufferLayerConsumer.cpp
void BufferLayerConsumer::setContentsChangedListener(const wp<ContentsChangedListener>& listener) {
    setFrameAvailableListener(listener);
    Mutex::Autolock lock(mMutex);
    mContentsChangedListener = listener;
}

setContentsChangedListener在哪调用呢

/frameworks/native/services/surfaceflinger/BufferQueueLayer.cpp
void BufferQueueLayer::onFirstRef() {
       BufferLayer::onFirstRef();

    // Creates a custom BufferQueue for SurfaceFlingerConsumer to use
    sp<IGraphicBufferProducer> producer;
    sp<IGraphicBufferConsumer> consumer;
    mFlinger->getFactory().createBufferQueue(&producer, &consumer, true);
    mProducer = mFlinger->getFactory().createMonitoredProducer(producer, mFlinger, this);
    mConsumer =
            mFlinger->getFactory().createBufferLayerConsumer(consumer, mFlinger->getRenderEngine(),
                                                             mTextureName, this);    
  mContentsChangedListener = new ContentsChangedListener(this);
    mConsumer->setContentsChangedListener(mContentsChangedListener);//@1
    mConsumer->setName(String8(mName.data(), mName.size()));

    // BufferQueueCore::mMaxDequeuedBufferCount is default to 1
    if (!mFlinger->isLayerTripleBufferingDisabled()) {
        mProducer->setMaxDequeuedBufferCount(2);
    }
}

@1可以明显的看到一路传的listener 为 ContentsChangedListener，
它的继承关系

/frameworks/native/services/surfaceflinger/BufferQueueLayer.h
class ContentsChangedListener : public BufferLayerConsumer::ContentsChangedListener
 
/frameworks/native/services/surfaceflinger/BufferLayerConsumer.h
struct ContentsChangedListener : public FrameAvailableListener 

所以第三步的onFrameAvailable是调用的ContentsChangedListener的。

/frameworks/native/services/surfaceflinger/BufferQueueLayer.cpp
void BufferQueueLayer::ContentsChangedListener::onFrameAvailable(const BufferItem& item) {
    Mutex::Autolock lock(mMutex);
    if (mBufferQueueLayer != nullptr) {
        mBufferQueueLayer->onFrameAvailable(item); //@1
 }
}

@1处 很明显调用的是类BufferQueueLayer中的onFrameAvailable方法

void BufferQueueLayer::onFrameAvailable(const BufferItem& item) {
 ......
    ATRACE_CALL();
    // Add this buffer from our internal queue tracker
    { // Autolock scope
        const nsecs_t presentTime = item.mIsAutoTimestamp ? 0 : item.mTimestamp;
        mFlinger->mScheduler->recordLayerHistory(this, presentTime,                                                 LayerHistory::LayerUpdateType::Buffer);

        Mutex::Autolock lock(mQueueItemLock);
        // Reset the frame number tracker when we receive the first buffer after
        // a frame number reset
        if (item.mFrameNumber == 1) {
            mLastFrameNumberReceived = 0;
        }

        // Ensure that callbacks are handled in order
        while (item.mFrameNumber != mLastFrameNumberReceived + 1) {
            status_t result = mQueueItemCondition.waitRelative(mQueueItemLock, ms2ns(500));
            if (result != NO_ERROR) {
                ALOGE("[%s] Timed out waiting on callback", getDebugName());
                break;
            }
        }

        mQueueItems.push_back(item);//@1
        mQueuedFrames++;

        // Wake up any pending callbacks
        mLastFrameNumberReceived = item.mFrameNumber;
        mQueueItemCondition.broadcast();
    }

    mFlinger->mInterceptor->saveBufferUpdate(layerId, item.mGraphicBuffer->getWidth(),
                                             item.mGraphicBuffer->getHeight(), item.mFrameNumber);

    mFlinger->signalLayerUpdate(); //@2
    mConsumer->onBufferAvailable(item);
}

@1处 把一路传过来的 item存储到mQueueItems，后面合成的时候在执行updateTextImage时候能用到，
@2处 去通知SurfaceFlinger进行合成。到这里，应用端（Producer）生产完Buffer这件事，就通知到了SurfaceFlinger中了。

/frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
void SurfaceFlinger::signalLayerUpdate() {
    mScheduler->resetIdleTimer();
    mPowerAdvisor.notifyDisplayUpdateImminent();
    mEventQueue->invalidate();
}

SurfaceFlinger的signalLayerUpdate，是通过MessageQueue来处理的，有一点需要注意的是上面这一些列操作是在binder线程里面执行的。通知到了当然就要请求vsync 进行刷新了。通过调用mEventQueue->invalidate() 来请求vsync信号。

二、surfaceFlinger vsync信号的申请

在Vsync与app、SurfaceFlinger关系(2)里面说过app vsyn信号的申请，surfaceFlinger vsync申请基本类似。这里大致说一下。

/frameworks/native/services/surfaceflinger/Scheduler/MessageQueue.cpp
void MessageQueue::invalidate() {
    mEvents->requestNextVsync();
}

接着上一步，会调用到MessageQueue 的invalidate,然后调用EventThreadConnection的requestNextVsync,

/frameworks/native/services/surfaceflinger/Scheduler/EventThread.cpp
void EventThreadConnection::requestNextVsync() {
    ATRACE_NAME("requestNextVsync");
    mEventThread->requestNextVsync(this);
}

再调用EventThread 的requestNextVsync

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(); @1
    }
}

EventThread 在创建的时候会执行其threadMain方法，其里面是一个while循环。主要内容是申请Vsync信号、Vsync信号申请到后进行分发。

void EventThread::threadMain(std::unique_lock<std::mutex>& lock) {
DisplayEventConsumers consumers;
        // Find connections that should consume this event.
        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); //@1
                }

                ++it;
            } else {
                it = mDisplayEventConnections.erase(it);
            }
        }
......
        if (!consumers.empty()) {
            dispatchEvent(*event, consumers); //@2
            consumers.clear();
        }
......
        if (mState != nextState) {
           if (mState == State::VSync) {
                   mVSyncSource->setVSyncEnabled(false);
           } else if (nextState == State::VSync) {
                mVSyncSource->setVSyncEnabled(true);//@3
            }

            mState = nextState;
       }
......
}

@1处 把mDisplayEventConnections又存入了DisplayEventConsumers 中，为后面的分发做准备。
@2处 对注册了connection 其Vsync 信号的分发。
@3处是要进行vsync的申请。可参考Vsync与app、SurfaceFlinger关系(1)。
请求到了后，Vsync经过DispSync.cpp 、 DispSyncSource.cpp 到EventThread的onVSyncEvent

/frameworks/native/services/surfaceflinger/Scheduler/EventThread.cpp
void EventThread::onVSyncEvent(nsecs_t timestamp, nsecs_t expectedVSyncTimestamp) {
    std::lock_guard<std::mutex> lock(mMutex);

    LOG_FATAL_IF(!mVSyncState);
    mPendingEvents.push_back(makeVSync(mVSyncState->displayId, timestamp, ++mVSyncState->count,
                                       expectedVSyncTimestamp));
    mCondition.notify_all(); @4
}

在@4处就会唤起threadMain里面的锁，继续进行下一轮的循环，然后会执行到@2处，进行vsync信号的分发。已经说过，再简单介绍一下过程

/frameworks/native/services/surfaceflinger/Scheduler/EventThread.cpp
void EventThread::dispatchEvent(const DisplayEventReceiver::Event& event,
                                const DisplayEventConsumers& consumers) {
    for (const auto& consumer : consumers) {
        switch (consumer->postEvent(event)) {  @1
            case NO_ERROR:
                break;

            case -EAGAIN:
                // TODO: Try again if pipe is full.
                ALOGW("Failed dispatching %s for %s", toString(event).c_str(),
                      toString(*consumer).c_str());
                break;

            default:
                // Treat EPIPE and other errors as fatal.
                removeDisplayEventConnectionLocked(consumer);  @2；
        }
    }
}

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);
}

/frameworks/native/libs/gui/DisplayEventReceiver.cpp
ssize_t DisplayEventReceiver::sendEvents(gui::BitTube* dataChannel,
        Event const* events, size_t count)
{
    return gui::BitTube::sendObjects(dataChannel, events, count);
}

最后就到达了 MessageQueue 的 eventReceiver

int MessageQueue::eventReceiver(int /*fd*/, int /*events*/) {
    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(buffer[i].vsync.expectedVSyncTimestamp);
                break;
            }
        }
    }
    return 1;
}

DisplayEventReceiver::getEvents 接收到消息，满足条件执行下面的mHandler->dispatchInvalidate

/frameworks/native/services/surfaceflinger/Scheduler/MessageQueue.cpp
void MessageQueue::Handler::dispatchInvalidate(nsecs_t expectedVSyncTimestamp) {
    if ((android_atomic_or(eventMaskInvalidate, &mEventMask) & eventMaskInvalidate) == 0) {
        mExpectedVSyncTime = expectedVSyncTimestamp;
        mQueue.mLooper->sendMessage(this, Message(MessageQueue::INVALIDATE));
    }
}

void MessageQueue::Handler::handleMessage(const Message& message) {
    switch (message.what) {
        case INVALIDATE:
            android_atomic_and(~eventMaskInvalidate, &mEventMask);
            mQueue.mFlinger->onMessageReceived(message.what, mExpectedVSyncTime);
            break;
        case REFRESH:
            android_atomic_and(~eventMaskRefresh, &mEventMask);
            mQueue.mFlinger->onMessageReceived(message.what, mExpectedVSyncTime);
            break;
    }
}

一路操作，终于到surfaceFlinger了。合成的两大重要方法，onMessageInvalidate、onMessageRefresh；

/frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
void SurfaceFlinger::onMessageReceived(int32_t what, nsecs_t expectedVSyncTime) {
    ATRACE_CALL();
    switch (what) {
        case MessageQueue::INVALIDATE: {
            onMessageInvalidate(expectedVSyncTime);
            break;
        }
        case MessageQueue::REFRESH: {
            onMessageRefresh();
            break;
        }
    }
}