Android显示vsync信号的虚拟化和处理流程

最新推荐文章于 2025-06-06 16:42:23 发布

ywlyg

最新推荐文章于 2025-06-06 16:42:23 发布

阅读量3.1k

点赞数 1

CC 4.0 BY-SA版权

分类专栏： Android显示架构

本文链接：https://blog.youkuaiyun.com/ywlyg/article/details/82838637

本文深入探讨Android 4.4后引入的黄油计划，重点关注SurfaceFlinger如何处理vsync信号的虚拟化。从vsync的生成到传递，详细解析了SurfaceFlinger的初始化过程，以及信号如何唤醒和驱动线程。通过分析EventThread、DispSyncThread和DispSyncSource的角色，展示了Android系统中vsync信号从发生到应用层的完整路径。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Android系统在4.4之后加入了黄油计划，surfaceflinger对显示的处理也变得复杂起来。由于添加了vsyn虚拟化机制，app将要显示的内容和surfaceflinger对显示内容的合成分成了两个部分，而两者开始的信号都是从vsync发出的。这里就涉及vsync信号的发生和传递，并且考虑到性能原因，信号的发生和传递都是按需进行的。因此，研究vsync信号的虚拟化及其处理，有助于理解线程的休眠唤醒和surfaceflinger的架构。

本文参考三篇文章：

https://blog.youkuaiyun.com/jinzhuojun/article/details/17293325

https://blog.youkuaiyun.com/houliang120/article/details/50908098

https://blog.youkuaiyun.com/kc58236582/article/details/52763534

一：SurfaceFlinger的初始化

init{    
// start the EventThread
    sp<VSyncSource> vsyncSrc = new DispSyncSource(&mPrimaryDispSync,
            vsyncPhaseOffsetNs, true);
    mEventThread = new EventThread(vsyncSrc);
    sp<VSyncSource> sfVsyncSrc = new DispSyncSource(&mPrimaryDispSync,
            sfVsyncPhaseOffsetNs, false);
    mSFEventThread = new EventThread(sfVsyncSrc);//先开线程
    mEventQueue.setEventThread(mSFEventThread);//然后在设置connection

    mEventControlThread = new EventControlThread(this);
    mEventControlThread->run("EventControl", PRIORITY_URGENT_DISPLAY);
}

Vsync发出后，调用SF的方法：

bool HWComposer::VSyncThread::threadLoop() {
    { // scope for lock
        Mutex::Autolock _l(mLock);
        while (!mEnabled) {
            mCondition.wait(mLock);
        }
    }

    const nsecs_t period = mRefreshPeriod;
    const nsecs_t now = systemTime(CLOCK_MONOTONIC);
    nsecs_t next_vsync = mNextFakeVSync;
    nsecs_t sleep = next_vsync - now;
    if (sleep < 0) {
        // we missed, find where the next vsync should be
        sleep = (period - ((now - next_vsync) % period));
        next_vsync = now + sleep;
    }
    mNextFakeVSync = next_vsync + period;

    struct timespec spec;
    spec.tv_sec  = next_vsync / 1000000000;
    spec.tv_nsec = next_vsync % 1000000000;

    int err;
    do {
        err = clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &spec, NULL);
    } while (err<0 && errno == EINTR);

    if (err == 0) {
        mHwc.mEventHandler.onVSyncReceived(0, next_vsync);
    }

    return true;
}

进入SF的方法：

void SurfaceFlinger::onVSyncReceived(int type, nsecs_t timestamp) {
    bool needsHwVsync = false;

    { // Scope for the lock
        Mutex::Autolock _l(mHWVsyncLock);
        if (type == 0 && mPrimaryHWVsyncEnabled) {
            needsHwVsync = mPrimaryDispSync.addResyncSample(timestamp);
        }
    }

    if (needsHwVsync) {
        enableHardwareVsync();
    } else {
        disableHardwareVsync(false);
    }
}

进入

bool DispSync::addResyncSample(nsecs_t timestamp) {
    Mutex::Autolock lock(mMutex);

    size_t idx = (mFirstResyncSample + mNumResyncSamples) % MAX_RESYNC_SAMPLES;
    mResyncSamples[idx] = timestamp;

    if (mNumResyncSamples < MAX_RESYNC_SAMPLES) {
        mNumResyncSamples++;
    } else {
        mFirstResyncSample = (mFirstResyncSample + 1) % MAX_RESYNC_SAMPLES;
    }

    updateModelLocked();

    if (mNumResyncSamplesSincePresent++ > MAX_RESYNC_SAMPLES_WITHOUT_PRESENT) {
        resetErrorLocked();
    }

    if (runningWithoutSyncFramework) {
        // If we don't have the sync framework we will never have
        // addPresentFence called.  This means we have no way to know whether
        // or not we're synchronized with the HW vsyncs, so we just request
        // that the HW vsync events be turned on whenever we need to generate
        // SW vsync events.
        return mThread->hasAnyEventListeners();
    }

    return mPeriod == 0 || mError > errorThreshold;
}

进入

void DispSync::updateModelLocked() {
    if (mNumResyncSamples >= MIN_RESYNC_SAMPLES_FOR_UPDATE) {
        nsecs_t durationSum = 0;
        for (size_t i = 1; i < mNumResyncSamples; i++) {
            size_t idx = (mFirstResyncSample + i) % MAX_RESYNC_SAMPLES;
            size_t prev = (idx + MAX_RESYNC_SAMPLES - 1) % MAX_RESYNC_SAMPLES;
            durationSum += mResyncSamples[idx] - mResyncSamples[prev];
        }

        mPeriod = durationSum / (mNumResyncSamples - 1);

        double sampleAvgX = 0;
        double sampleAvgY = 0;
        double scale = 2.0 * M_PI / double(mPeriod);
        for (size_t i = 0;