Vsync同步机制二

SurfaceFlinger Vsync初始化过程

DispVsync是软件Vsync的信号源，是SurfaceFlinger中的一个变量，在SurfaceFlinger的init方法中会根据DispVsync初始化相关Vsync相关的变量。

void SurfaceFlinger::init() {
    ......
    sp<VSyncSource> vsyncSrc = new DispSyncSource(&mPrimaryDispSync,
            vsyncPhaseOffsetNs, true, "app");
    mEventThread = new EventThread(vsyncSrc);
    sp<VSyncSource> sfVsyncSrc = new DispSyncSource(&mPrimaryDispSync,
            sfVsyncPhaseOffsetNs, true, "sf");
    mSFEventThread = new EventThread(sfVsyncSrc);
    mEventQueue.setEventThread(mSFEventThread);
    .......
    //如果HWC硬件有问题，就设置DispSync的周期模型为16.6ms
    if (mHwc->initCheck() != NO_ERROR) {
        mPrimaryDispSync.setPeriod(16666667);
    }
}

SurfaceFlinger的init方法中,根据mPrimaryDispSync分别创建了app的DisplaySyncSource对象，和一个SF的DisplaySyncSource对象。然后根据App的DisplaySyncSource创建了一个App的EventThread，根据SF的DisplaySyncSource创建了一个SF的EventThread。
上一篇分析了软件Vsync产生过程，以及DispSyncSource。接着看下EventThread。

EventThread

EventThread::EventThread(const sp<VSyncSource>& src)
    : mVSyncSource(src),
      mUseSoftwareVSync(false),
      mVsyncEnabled(false),
      mDebugVsyncEnabled(false),
      mVsyncHintSent(false) {
    
    //初始化mVSyncEvent数组。
    //mVSyncEvent数组中的每个数组成员都代表一个显示设备的Vsync事件。将这个事件timestamp初始化
    for (int32_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) {
        mVSyncEvent[i].header.type = DisplayEventReceiver::DISPLAY_EVENT_VSYNC;
        mVSyncEvent[i].header.id = 0;
        mVSyncEvent[i].header.timestamp = 0;
        mVSyncEvent[i].vsync.count =  0;
    }

    ......
}

EventThread 创建对象后会触发onFirstRef方法，onFirstRef方法会触发线程run方法执行EventThread的threadloop方法。

bool EventThread::threadLoop() {
    DisplayEventReceiver::Event event;
    //初始化一个Connection列表
    Vector< sp<EventThread::Connection> > signalConnections;
    //等待事件到来，判断是否需要触发Connection回调，将需要触发的Connection放入Connection列表中
    signalConnections = waitForEvent(&event);

    // 分发事件给listener
    const size_t count = signalConnections.size();
    for (size_t i=0 ; i<count ; i++) {
        const sp<Connection>& conn(signalConnections[i]);
        // 调用postEvent方法，将事件通知监听者
        status_t err = conn->postEvent(event);
        
        ......
    }
    return true;
}

// 等待事件到来
Vector< sp<EventThread::Connection> > EventThread::waitForEvent(
        DisplayEventReceiver::Event* event)
{
    Mutex::Autolock _l(mLock);
    Vector< sp<EventThread::Connection> > signalConnections;

    do {
        bool eventPending = false;
        bool waitForVSync = false;

        size_t vsyncCount = 0;
        nsecs_t timestamp = 0;
        //检测mVSyncEvent数组，查看检查具体设备是否有Vsync事件到来，mVSyncEvent[i].header.timestamp值不为0，则表示有新的Vsync事件
        for (int32_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) {
            timestamp = mVSyncEvent[i].header.timestamp;
            if (timestamp) {
                //timeStamp 不为0， 表示有新的Vsync事件，将该事件存放到event中
                *event = mVSyncEvent[i];
                mVSyncEvent[i].header.timestamp = 0;
                vsyncCount = mVSyncEvent[i].vsync.count;
                break;
            }
        }

        if (!timestamp) {
            // 如果没有Vsync事件，则查看下是否有其他事件
            eventPending = !mPendingEvents.isEmpty();
            if (eventPending) {
                // 有其他事件的话同样存放到event中
                *event = mPendingEvents[0];
                mPendingEvents.removeAt(0);
            }
        }

        // 查找所有等待事件的Connection
        // mDisplayEventConnections保存的是注册的Connection的,
        // SF EventThread线程里只有一个Connection, 而这个Connection主要是用来渲染
        // 而如果是APP EventThread, 这里会有多个connection
        size_t count = mDisplayEventConnections.size();
        for (size_t i=0 ; i<count ; i++) {
            sp<Connection> connection(mDisplayEventConnections[i].promote());
            if (connection != NULL) {
                bool added = false;
                //这里的connection->count的值的大小有如下含义
                // count >= 1 : continuous event. count is the vsync rate  如果在大于等于1，表示会持续接收vsync event
                // count == 0 : one-shot event that has not fired    表示只接收一次
                // count ==-1 : one-shot event that fired this round / disabled   等于-1，表示不能再接收vsync事件了
                if (connection->count >= 0) {
                    waitForVSync = true;
                    if (timestamp) {
                        // 只接收一次Vsync事件，接收到之后将count 设置为-1, 下次这个Connection便不在接收事件
                        if (connection->count == 0) {
                            connection->count = -1;
                            signalConnections.add(connection);
                            added = true;
                        } else if (connection->count == 1 ||
                                (vsyncCount % connection->count) == 0) {
                            // continuous event, and time to report it
                            signalConnections.add(connection);
                            added = true;
                        }
                    }
                }

                if (eventPending && !timestamp && !added) {
                    //添加到关注的Connection列表
                    signalConnections.add(connection);
                }
            } else {
                // we couldn't promote this reference, the connection has
                // died, so clean-up!
                mDisplayEventConnections.removeAt(i);
                --i; --count;
            }
        }

        ......

        // 既没有vsync事件，也没有其它pending的事件(hotplug事件)
        if (!timestamp && !eventPending) {
        
            if (waitForVSync) {
                
                bool softwareSync = mUseSoftwareVSync;
                nsecs_t timeout = softwareSync ? ms2ns(16) : ms2ns(1000);
                if (mCondition.waitRelative(mLock, timeout) == TIMED_OUT) {
                    if (!softwareSync) {
                        ALOGW("Timed out waiting for hw vsync; faking it");
                    }
                    //如果是driver的bug,如果硬件一直不上报vsync事件怎么办？？难道就一直等下去？？那client不就饿死了么？
                    //所以这里如果driver不报vsync，那么就软件模拟一个vsync事件，这里的timeout是1000ms，发一个
                    mVSyncEvent[0].header.type = DisplayEventReceiver::DISPLAY_EVENT_VSYNC;
                    mVSyncEvent[0].header.id = DisplayDevice::DISPLAY_PRIMARY;
                    mVSyncEvent[0].header.timestamp = systemTime(SYSTEM_TIME_MONOTONIC);
                    mVSyncEvent[0].vsync.count++;
                }
            } else {
                //既没有client, 又没有硬件vsync事件，那么就死等下去了
                mCondition.wait(mLock);
            }
        }
    //没有事件则就行检测消息或者等待    
    } while (signalConnections.isEmpty());

    //返回关注消息的Connection
    return signalConnections;
}

EventThread会开启一个线程，该线程用于等待Vsync事件或者hotplug事件。当有任何一个事件到来的时候，EventThread线程会收集所有关注该事件的连接，通过Connection连接通知所有关注该事件的监听者.
EventThread中维护了一个Connection类型的列表 mDisplayEventConnections，该列表中维护了所有关注EventThread事件的监听者，但是每次Vsync事件或者hotplug事件到来时，并不是每一个在该列表中的监听者都会关心此次事件，我们要做的就是从列表中找出关心此次事件的监听者，然后将消息传递给他.
但是，如何区分哪个Connection关心此次事件呢？
在每一个Connection中维护了一个count变量，该变量有三个取值。

count >= 1 : continuous event. count is the vsync rate 如果在大于等于1，表示会持续接收vsync event
count == 0 : one-shot event that has not fired 表示只接收一次，接收完这次事件以后就会将count修改成了-1
count ==-1 : one-shot event that fired this round / disabled 等于-1，表示不能再接收vsync事件了

根据这三种类型，将count >=0的 Connection添加到Connection列表，然后统一发送消息，通知监听者。

count的值是什么时候修改呢？
就是在EventThread的requestNextVsync方法中.

void EventThread::requestNextVsync(
        const sp<EventThread::Connection>& connection) {
    Mutex::Autolock _l(mLock);
    if (connection->count < 0) {
        connection->count = 0;
        mCondition.broadcast();
    }
}

requstNextVsync表示请求接收下一次Vsync事件。在系统里APP和SurfaceFlinger都会利用该方法请求下一次Vsync到来的时候被叫起来做事情，也就是时候，虽然系统硬件每秒会有60个Vsync事件，但是并不代表软件Vsync每个Vsync都会做事情,也正是这样，Android系统根据软件Vsync来做事情，软件Vsync又是根据硬件Vsync样本来计算推测下一个Vsync的时间。

MessageQueue和Connection

SurfaceFlinger init初始化的时候，创建了两个EventThread，MessageQueue设置EventThread为SF的EventThread。代码如下

   sp<VSyncSource> sfVsyncSrc = new DispSyncSource(&mPrimaryDispSync,
            sfVsyncPhaseOffsetNs, true, "sf");
    mSFEventThread = new EventThread(sfVsyncSrc);
    mEventQueue.setEventThread(mSFEventThread);

DisplaySyncThread和EventThread已经分析过了，直接看MessageQueue的setEventThread方法.

void MessageQueue::setEventThread(const sp<EventThread>& eventThread)
{
    mEventThread = eventThread;
    mEvents = eventThread->createEventConnection();
    mEventTube = mEvents->getDataChannel();
    mLooper->addFd(mEventTube->getFd(), 0, Looper::EVENT_INPUT,
            MessageQueue::cb_eventReceiver, this);
}


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

                break;
            }
        }
    }
    return 1;
}

setEventThread做了什么工作？
1:调用SF EventThread的createEventConnection方法，创建MessageQueue和EventThread的连接，，表示MessageQueue是SF EventThread的监听者. 这个连接会创建一个Socket通信， EventThread端持有Socket Server端,MessageQueue持有Socket Client端.
2:获取mEvent的Socket的Client端，Socket创建在EventTube中，不在详细分析.
3:获取到Socket Client的文件描述符fd,添加到MessageQueue的Looper中进行监控.档EventThread发送通知消息的时候，回调cb_eventReceiver方法.
4:收到eventReceiver回调后，发送Handler消息给MessageQueue消息队列，由MessageQueue的handlerMessage调用SurfaceFlinger处理. 以前我们讲过,MessageQueue作为SurfaceFlinger的主线程，此时就交由SurfaceFliger主线程来处理合成了

总结

Vsync产生过程

Vsync产生过程如上图:
1：HWC产生硬件Vsync信号，添加到DispSync样本中
2：DispSync计算周期和偏差，然后根据APP和SF设置的时间偏差，根据Vsync信号各自计算SF和APP Vsync回调时间.
3：DispSync通过VsyncSource通知了App 和 SF的EventThread线程
4：APP EventThread暂时不管， SF的EventThread收到消息后，收集对该Vsync事件感兴趣的监听者，发送消息命令，通过Connection Socket的服务端来通知客户端。
5：MessageQueue作为SF EventThread的监听者，和EventThread创建了Connection，监听了Connection Socket 客户端，监听消息。收到消息后通过Message的Handler发送到SF的主线程 MessageQueue消息队列中.
6:MessageQueue消息队列handleMessage处理消息，调用SF的invlidate来更新合成图像。

此时Vsync整个流程就简单分析完成了

Vsync同步机制 二

SurfaceFlinger Vsync初始化过程

EventThread

MessageQueue和Connection

总结

Vsync同步机制二