Android VSync信号产生过程源码分析

在上一篇Android Project Butter分析中介绍了Android4.1通过引入VSync机制来改善显示效果,并分析了VSync机制的原理。本文主要分析VSync信号的产生过程。VSync信号产生有两种方式,一种是硬件中断产生,另一种是使用软件模拟产生,至于使用何种方式产生VSync信号,就和硬件系统配置有关。在Android4.1以后的版本中,定义了HWComposer硬件抽象模块来负责产生VSync信号。HWComposer硬件抽象层定义:

hardware\libhardware\modules\hwcomposer\hwcomposer.cpp

hwc_module_t HAL_MODULE_INFO_SYM = {
    common: {
        tag: HARDWARE_MODULE_TAG,
        version_major: 1,
        version_minor: 0,
        id: HWC_HARDWARE_MODULE_ID,
        name: "Sample hwcomposer module",
        author: "The Android Open Source Project",
        methods: &hwc_module_methods,
    }
};

注册的硬件抽象模块方法定义如下:

static struct hw_module_methods_t hwc_module_methods = {
    open: hwc_device_open
};

关于为硬件抽象模块HWComposer定义的数据结构之间的关系如下下图所示:

在初始化DisplayHardware对象时,会创建一个HWComposer对象:

void DisplayHardware::init(uint32_t dpy)
{
	...
    // initialize the H/W composer
    mHwc = new HWComposer(mFlinger, *this, mRefreshPeriod);
    if (mHwc->initCheck() == NO_ERROR) {
        mHwc->setFrameBuffer(mDisplay, mSurface);
    }
}

这里使用SurfaceFlinger,DisplayHardware对象及屏幕刷新周期来构造HWComposer对象,HWComposer的构造过程如下:

frameworks\native\services\surfaceflinger\DisplayHardware\HWComposer.cpp

HWComposer::HWComposer(const sp<SurfaceFlinger>& flinger,EventHandler& handler,nsecs_t refreshPeriod)
    : mFlinger(flinger),
      mModule(0), mHwc(0), mList(0), mCapacity(0),
      mNumOVLayers(0), mNumFBLayers(0),
      mDpy(EGL_NO_DISPLAY), mSur(EGL_NO_SURFACE),
      mEventHandler(handler),
      mRefreshPeriod(refreshPeriod),
      mVSyncCount(0), mDebugForceFakeVSync(false)
{
    char value[PROPERTY_VALUE_MAX];
    property_get("debug.sf.no_hw_vsync", value, "0");
    mDebugForceFakeVSync = atoi(value);
	//是否需要软件模拟VSync
    bool needVSyncThread = false;
	//加载HWComposer硬件抽象模块
    int err = hw_get_module(HWC_HARDWARE_MODULE_ID, &mModule);
    ALOGW_IF(err, "%s module not found", HWC_HARDWARE_MODULE_ID);
    if (err == 0) {
		//打开HWComposer硬件抽象模块
        err = hwc_open(mModule, &mHwc);
        if (err == 0) {
			//打开成功,注册回调函数
            if (mHwc->registerProcs) {
                mCBContext.hwc = this;
                mCBContext.procs.invalidate = &hook_invalidate;
                mCBContext.procs.vsync = &hook_vsync;
                mHwc->registerProcs(mHwc, &mCBContext.procs);
                memset(mCBContext.procs.zero, 0, sizeof(mCBContext.procs.zero));
            }
            if (mHwc->common.version >= HWC_DEVICE_API_VERSION_0_3) {
                if (mDebugForceFakeVSync) {
                    // make sure to turn h/w vsync off in "fake vsync" mode
                    mHwc->methods->eventControl(mHwc, HWC_EVENT_VSYNC, 0);
                }
            } else {
                needVSyncThread = true;
            }
        }
    } else {
        needVSyncThread = true;
    }
	//如果HWComposer硬件抽象模块打开失败或者HWComposer硬件抽象模块的版本小于HWC_DEVICE_API_VERSION_0_3,则采用软件模拟产生VSync信号
    if (needVSyncThread) {
        //创建VSync产生线程VSyncThread
        mVSyncThread = new VSyncThread(*this);
    }
}

在构造HWComposer对象时,选择了VSync信号产生方式:1.硬件产生;2.软件模拟产生;假如当前系统可以成功加载HWC_HARDWARE_MODULE_ID=hwcomposer,并且通过这个库能顺利打开设备(hwc_composer_device_t),并且其版本号又大于HWC_DEVICE_API_VERSION_0_3的话,我们就采用硬件方式产生VSync,否则需要创建一个新的VSync线程来模拟产生信号。

1.硬件产生VSync信号过程

Android定义了hwcomposer硬件抽象模块来负责产生VSync信号,因此在使用硬件方式产生VSync信号时,需要首先加载并打开hwcomposer硬件抽象模块。硬件抽象模块的加载过程已经在 Android硬件抽象Hardware库加载过程源码分析详细分析了,因此在这里只介绍hwcomposer硬件模块的打开过程:
err = hwc_open(mModule, &mHwc);
mModule为hw_module_t类型变量,用于描述hwcomposer硬件抽象模块,参数mHwc的类型为hwc_composer_device_t,该结构用于描述hwcomposer硬件设备。
static inline int hwc_open(const struct hw_module_t* module,
        hwc_composer_device_t** device) {
    return module->methods->open(module,
            HWC_HARDWARE_COMPOSER, (struct hw_device_t**)device);
}
在定义hwcomposer硬件抽象层时,注册了该硬件抽象模块的打开回调函数hwc_device_open,其实现过程如下:
static int hwc_device_open(const struct hw_module_t* module, const char* name,struct hw_device_t** device)
{
    int status = -EINVAL;
    if (!strcmp(name, HWC_HARDWARE_COMPOSER)) {
        struct hwc_context_t *dev;
        dev = (hwc_context_t*)malloc(sizeof(*dev));
        /* initialize our state here */
        memset(dev, 0, sizeof(*dev));
        /* initialize the procs */
        dev->device.common.tag = HARDWARE_DEVICE_TAG;
        dev->device.common.version = 0;
        dev->device.common.module = const_cast<hw_module_t*>(module);
        dev->device.common.close = hwc_device_close;
        dev->device.prepare = hwc_prepare;
        dev->device.set = hwc_set;
        *device = &dev->device.common;
        status = 0;
    }
    return status;
}
打开hwcomposer硬件模块过程实际上是创建一个hwc_context_t对象,同时将该模块的回调函数注册到hwc_context_t对象中,如果mHwc->registerProcs不为空的话,我们注册硬件回调mCBContext.procs。当有事件产生时,比如vsync或者invalidate,硬件模块将分别通过procs.vsync和procs.invalidate来通知HWComposer。在这里可以创建一个线程专门负责响应VSync中断:
bool VSyncThread::threadLoop() {
    { // scope for lock
        Mutex::Autolock _l(mLock);
        while (!mEnabled) {
            mCondition.wait(mLock);
        }
    }
	//进入FrameBuffer驱动等待VSync中断到来
    if (ioctl(mFbFd, FBIO_WAITFORVSYNC, NULL) == -1)  {  
        ALOGE("fail to wait vsync , mFbFd:%d" , mFbFd);  
    }else{  
	  if(!mDev->procs || !mDev->procs->vsync){
	  	ALOGW("device procs or vsync is null procs:%x , vsync:%x", mDev->procs , mDev->procs->vsync);
	  	return true;
	  }
	  //调用VSync回调函数
      mDev->procs->vsync(mDev->procs, 0, systemTime(CLOCK_MONOTONIC));  
    }  
    return true;
}
在该线程运行过程中通过ioctl系统调用进入到fb驱动等待VSync中断,如果VSync中断到来,则ioctl函数从驱动中返回。同时如果注册了VSync回调处理函数,则调用该回调函数来响应VSync信号。在前面构造HWComposer对象时,我们已经注册了VSync中断回调函数为hook_vsync,该函数的实现如下:
void HWComposer::hook_vsync(struct hwc_procs* procs, int dpy, int64_t timestamp) {
    reinterpret_cast<cb_context *>(procs)->hwc->vsync(dpy, timestamp);
}
在该函数里调用HWComposer对象的vsync函数来出来响应VSync中断
void HWComposer::vsync(int dpy, int64_t timestamp) {
    ATRACE_INT("VSYNC", ++mVSyncCount&1);
    mEventHandler.onVSyncReceived(dpy, timestamp);
}
mEventHandler为DisplayHardware对象,这里又将VSync中断信号交给DisplayHardware对象处理,DisplayHardware继承于EventHandler类,并实现了该类的虚方法onVSyncReceived,这里调用DisplayHardware对象的onVSyncReceived函数来处理VSync中断信号。关于VSync信号的处理在稍后介绍,到此硬件产生VSync信号的过程就完成了。

2.软件模拟产生VSync信号过程

在构造HWComposer对象时,如果打开hwcomposer硬件抽象模块失败的话就使用软件方式模拟产生VSync信号,软件模拟产生过程就是通过一个线程间隔一段时间调用一次VSync回调函数,从而模拟VSync信号中断效果。首先创建一个专门用于产生VSync信号的线程:
HWComposer::VSyncThread::VSyncThread(HWComposer& hwc)
    : mHwc(hwc), mEnabled(false),
      mNextFakeVSync(0),
      mRefreshPeriod(hwc.mRefreshPeriod)
{
}
VSyncThread继承于RefBase类,该对象第一次强引用自动调用onFirstRef()函数,在该函数中启动线程
 
void HWComposer::VSyncThread::onFirstRef() {
    run("VSyncThread", PRIORITY_URGENT_DISPLAY + PRIORITY_MORE_FAVORABLE);
}
VSyncThread线程的执行过程如下:
bool HWComposer::VSyncThread::threadLoop() {
    { // scope for lock
        Mutex::Autolock _l(mLock);
        while (!mEnabled) {//VSyncThread线程启动后并不立即产生VSync信号,只有通过调用setEnabled函数使能VSync信号后,该线程才往下执行,从而产生VSync信号
            mCondition.wait(mLock);
        }
    }
    const nsecs_t period = mRefreshPeriod;//VSync信号的产生间隔时间,屏幕刷新时间
    const nsecs_t now = systemTime(CLOCK_MONOTONIC);
    nsecs_t next_vsync = mNextFakeVSync;//下一次VSync信号产生时间
    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);
	//每隔屏幕刷新时间间隔调用一次onVSyncReceived函数
    if (err == 0) {
        mHwc.mEventHandler.onVSyncReceived(0, next_vsync);
    }
	//一次信号产生完成后,函数直接返回true,当threadLoop返回值为“真”时,它将被系统再一次调用,从而循环起来。
    return true;
}
mEnabled用于控制是否产生VSync信号。当希望关闭VSync信号发生源时,调用VSyncThread::setEnabled(false),否则传入true。mEnabled为false时,VSyncThread就处于等待状态,直到再次使能这个线程。
VSync产生步骤:
1)计算下一次产生VSync信号的时间
2)线程进入休眠
3)休眠时间到了后,发出VSync信号了,通知感兴趣的人
4)循环往复
屏幕刷新周期计算公式:mRefreshPeriod = nsecs_t(1e9 / mRefreshRate);如果屏幕刷新频率mRefreshRate为60Hz的话,mRefreshPeriod就差不多是16ms。mNextFakeVSync代表下一次产生信号的时间点,mNextFakeVSync代表的是下一次threadLoop需要用到的时间点,所以首先将next_vsync=mNextFakeVSync。然后计算产生下一次VSync信号需要睡眠的时间:sleep = (period - ((now - next_vsync) % period));

当休眠时间到了后,函数跳出while循环,表示VSync信号产生的时刻到了,这时就调用成员变量mEventHandler的onVSyncReceived函数来响应VSync信号,软件模拟产生VSync信号的间隔时间就是屏幕刷新周期。成员变量mEventHandler的类型为EventHandler,在HWComposer的构造函数中,该变量指向DisplayHardware对象,因此这里调用的是DisplayHardware对象的onVSyncReceived函数来处理VSync中断。这里可以看出,无论是硬件产生VSync还是软件模拟产生VSync信号,最终都是交给DisplayHardware对象处理:

void DisplayHardware::onVSyncReceived(int dpy, nsecs_t timestamp) {
    sp<VSyncHandler> handler;
    { // scope for the lock
        Mutex::Autolock _l(mLock);
        mLastHwVSync = timestamp;
        if (mVSyncHandler != NULL) {
            handler = mVSyncHandler.promote();
        }
    }

    if (handler != NULL) {
        handler->onVSyncReceived(dpy, timestamp);
    }
}

DisplayHardware的成员变量mVSyncHandler的类型为VSyncHandler,EventThread类继承于VSyncHandler类,在EventThread的onFirstRef()函数中,通过调用DisplayHardware的setVSyncHandler函数将构造的EventThread对象保存到DisplayHardware的成员变量mVSyncHandler中
void EventThread::onFirstRef() {
    mHw.setVSyncHandler(this);
    ...
}
因此DisplayHardware的成员变量mVSyncHandler实际指向的是EventThread对象。
void DisplayHardware::setVSyncHandler(const sp<VSyncHandler>& handler) {
    Mutex::Autolock _l(mLock);
    mVSyncHandler = handler;
}
由此可以看出,对VSync的处理又被DisplayHardware对象转交给了EventThread来完成。EventThread是一个线程类,该线程专门负责分发VSync信号。
void EventThread::onVSyncReceived(int, nsecs_t timestamp) {
    Mutex::Autolock _l(mLock);
    mVSyncTimestamp = timestamp;
    mCondition.broadcast();
}
VSync信号产生后,仅仅简单地打开线程互斥量,从而唤醒EventThread线程,让EventThread线程分发VSync信号到来事件给所有已经注册的连接。到此关于VSync信号的产生过程就介绍完了。
 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值