20181220_eglSwapBuffers详解

eglSwapBuffers详解

问题来自eglSwapBuffers是否有等待，如果调用eglSwapBuffers的话，是不是会导致帧率下降？

2.7.1 BootAnimation中的调用

之所以需要了解这个api的具体实现，因为我们需要了解eglSwapBuffers是否有等待Fence。

首先看下在BootAnimation中对于这个函数的调用：

EGLBoolean res = eglSwapBuffers(mDisplay, mSurface);         if (res == EGL_FALSE)             break;

故名思意，通过这个函数来实现buffer的互换，可是这个互换的buffer是怎么来的呢？

通过对代码的跟踪，可以知道，在bootanimation的readyToRun（）函数中，会来创建mSurface

surface = eglCreateWindowSurface(display, config, s.get(), NULL);

因为我们没有GPU驱动的代码，所以，我们可以从libagl中看出一点端倪。

查看这部分代码，建议将如下几部分的sourcecode导入到sourceinsight中。

l  frameworks/native/opengl/libagl

l  frameworks/base/cmds/bootanimation

l  frameworks/core/libpixelflinger

2.7.2 eglCreateWindowSurface

在egl.cpp中，eglCreateWindowSurface就是对应函数createWindowSurface的接口封装。

surface = eglCreateWindowSurface(display, config, s.get(), NULL);   EGLSurface eglCreateWindowSurface(  EGLDisplay dpy, EGLConfig config,                                     NativeWindowType window,                                     const EGLint *attrib_list) {     return createWindowSurface(dpy, config, window, attrib_list); }

在介绍createWindowSurface之前，先来看看window，这个window到底是什么。

在bootanimation.cpp中有这样的一个调用逻辑：

// create the native surface sp<SurfaceControl> control = session()->createSurface(String8("BootAnimation"), sp<Surface> s = control->getSurface();   sp<SurfaceControl> SurfaceComposerClient::createSurface(         const String8& name,         uint32_t w,         uint32_t h,         PixelFormat format,         uint32_t flags) {     sp<SurfaceControl> sur;     if (mStatus == NO_ERROR) {         sp<IBinder> handle;         sp<IGraphicBufferProducer> gbp;         status_t err = mClient->createSurface(name, w, h, format, flags,                 &handle, &gbp);         ALOGE_IF(err, "SurfaceComposerClient::createSurface error %s", strerror(-err));         if (err == NO_ERROR) {             sur = new SurfaceControl(this, handle, gbp);         }     }     return sur; }   sp<Surface> SurfaceControl::getSurface() const {     Mutex::Autolock _l(mLock);     if (mSurfaceData == 0) {         // This surface is always consumed by SurfaceFlinger, so the         // producerControlledByApp value doesn't matter; using false.         mSurfaceData = new Surface(mGraphicBufferProducer, false);     }     return mSurfaceData; }

首先获取到SurfaceComposerClient的对象，然后通过SurfaceComposerClient->createSurface()函数创建一个SurfaceControl。在SurfaceComposerClient中有一个成员变量mClient，实际上建立了一个到surfaceflinger的连接。通过这个通道调用surfaceFlinger的createSurface（）来完成layer的创建。这个具体不在这边展开。这里只是把时序图给出，详细请参考9.1小节。

getSurface返回了一个surface对象。该Surface握有App层面对于底层buffer的控制方式以及状态的管理。

好了，接下来看看surface->get()返回的到底是什么？我们知道surface继承了RefBase，所以get()实际上RefBase提供的函数。返回了surface的对象引用。

而surface继承了ANativeObjectBase模版，通过ANativeObjectBase模版，可以理解成surface类也继承了AnativeWindow和RefBase。

那么surface.get()作为AnativeWindow的类型参数传递给CreateWindowSurface也就好理解咯。

也就是window本质上就是surface。

弄明白了window，我们再来具体分析下createWindowSurface函数。

static EGLSurface createWindowSurface(EGLDisplay dpy, EGLConfig config,         NativeWindowType window, const EGLint* /*attrib_list*/) {     if (egl_display_t::is_valid(dpy) == EGL_FALSE)         return setError(EGL_BAD_DISPLAY, EGL_NO_SURFACE);     if (window == 0)         return setError(EGL_BAD_MATCH, EGL_NO_SURFACE);       EGLint surfaceType;     if (getConfigAttrib(dpy, config, EGL_SURFACE_TYPE, &surfaceType) == EGL_FALSE)         return EGL_FALSE;       if (!(surfaceType & EGL_WINDOW_BIT))         return setError(EGL_BAD_MATCH, EGL_NO_SURFACE);       if (static_cast<ANativeWindow*>(window)->common.magic !=             ANDROID_NATIVE_WINDOW_MAGIC) {         return setError(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);     }             EGLint configID;     if (getConfigAttrib(dpy, config, EGL_CONFIG_ID, &configID) == EGL_FALSE)         return EGL_FALSE;       int32_t depthFormat;     int32_t pixelFormat;     if (getConfigFormatInfo(configID, pixelFormat, depthFormat) != NO_ERROR) {         return setError(EGL_BAD_MATCH, EGL_NO_SURFACE);     }       // FIXME: we don't have access to the pixelFormat here just yet.     // (it's possible that the surface is not fully initialized)     // maybe this should be done after the page-flip     //if (EGLint(info.format) != pixelFormat)     //    return setError(EGL_BAD_MATCH, EGL_NO_SURFACE);       egl_surface_t* surface;     surface = new egl_window_surface_v2_t(dpy, config, depthFormat,             static_cast<ANativeWindow*>(window));       if (!surface->initCheck()) {         // there was a problem in the ctor, the error         // flag has been set.         delete surface;         surface = 0;     }     return surface; }

createWindowSurface函数根据传递进来的config & window构建了egl_window_surface_v2_t，并把对象指针返回。egl_window_surface_v2_t继承了egl_surface_t,提供了一套操作buffer的接口。

有了上面铺垫后，接下来来看看eglSwapBuffer的实现。

2.7.3 eglSwapBuffers

先看看bootanimation中对应这个函数的调用：

eglSwapBuffers(mDisplay, mSurface);

eglSwapBuffers的具体实现如下：

EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface draw) {     if (egl_display_t::is_valid(dpy) == EGL_FALSE)         return setError(EGL_BAD_DISPLAY, EGL_FALSE);       egl_surface_t* d = static_cast<egl_surface_t*>(draw);     if (!d->isValid())         return setError(EGL_BAD_SURFACE, EGL_FALSE);     if (d->dpy != dpy)         return setError(EGL_BAD_DISPLAY, EGL_FALSE);       // post the surface     d->swapBuffers();       // if it's bound to a context, update the buffer     if (d->ctx != EGL_NO_CONTEXT) {         d->bindDrawSurface((ogles_context_t*)d->ctx);         // if this surface is also the read surface of the context         // it is bound to, make sure to update the read buffer as well.         // The EGL spec is a little unclear about this.         egl_context_t* c = egl_context_t::context(d->ctx);         if (c->read == draw) {             d->bindReadSurface((ogles_context_t*)d->ctx);         }     }       return EGL_TRUE; }

eglSwapBuffers调用了EGLSurface draw中的swapBuffers方法。我们从2.7.2中的分析可以知道，draw指向了egl_window_surface_v2_t，所以在egl_window_surface_v2_t中swapBuffers的实现如下：

EGLBoolean egl_window_surface_v2_t::swapBuffers() {     if (!buffer) {         return setError(EGL_BAD_ACCESS, EGL_FALSE);     }         /*      * Handle eglSetSwapRectangleANDROID()      * We copyback from the front buffer      */     // 首先通过andSelf（）函数，算出在buffer中的dirtyRegion的区域，然后调用subtract将oldDirtyRegion中去掉了dirtyRegion区域，然后见这块区域从previousBuffer拷贝到当前的buffer中。     if (!dirtyRegion.isEmpty()) {         dirtyRegion.andSelf(Rect(buffer->width, buffer->height));         if (previousBuffer) {             // This was const Region copyBack, but that causes an             // internal compile error on simulator builds             /*const*/ Region copyBack(Region::subtract(oldDirtyRegion, dirtyRegion));             if (!copyBack.isEmpty()) {                 void* prevBits;                 if (lock(previousBuffer,                         GRALLOC_USAGE_SW_READ_OFTEN, &prevBits) == NO_ERROR) {                     // copy from previousBuffer to buffer                     copyBlt(buffer, bits, previousBuffer, prevBits, copyBack);                     unlock(previousBuffer);                 }             }         }         oldDirtyRegion = dirtyRegion;     }       // 减少引用     if (previousBuffer) {         previousBuffer->common.decRef(&previousBuffer->common);         previousBuffer = 0;     }     unlock(buffer); // 完成buffer内容的填充，然后将previousBuffer指向buffer，同时queue buffer     previousBuffer = buffer;     nativeWindow->queueBuffer(nativeWindow, buffer, -1);     buffer = 0;   // dequeue a new buffer // 然后dequeue一个新的buffer，并等待fence     int fenceFd = -1;     if (nativeWindow->dequeueBuffer(nativeWindow, &buffer, &fenceFd) == NO_ERROR) {         sp<Fence> fence(new Fence(fenceFd));         // 等待fence超时，就把buffer cancel掉。         if (fence->wait(Fence::TIMEOUT_NEVER)) {             nativeWindow->cancelBuffer(nativeWindow, buffer, fenceFd);             return setError(EGL_BAD_ALLOC, EGL_FALSE);         }           // reallocate the depth-buffer if needed         if ((width != buffer->width) || (height != buffer->height)) {             // TODO: we probably should reset the swap rect here             // if the window size has changed             width = buffer->width;             height = buffer->height;             if (depth.data) {                 free(depth.data);                 depth.width   = width;                 depth.height  = height;                 depth.stride  = buffer->stride;                 depth.data    = (GGLubyte*)malloc(depth.stride*depth.height*2);                 if (depth.data == 0) {                     setError(EGL_BAD_ALLOC, EGL_FALSE);                     return EGL_FALSE;                 }             }         }           // keep a reference on the buffer         buffer->common.incRef(&buffer->common);           // finally pin the buffer down         if (lock(buffer, GRALLOC_USAGE_SW_READ_OFTEN |                 GRALLOC_USAGE_SW_WRITE_OFTEN, &bits) != NO_ERROR) {             ALOGE("eglSwapBuffers() failed to lock buffer %p (%ux%u)",                     buffer, buffer->width, buffer->height);             return setError(EGL_BAD_ACCESS, EGL_FALSE);             // FIXME: we should make sure we're not accessing the buffer anymore         }     } else {         return setError(EGL_BAD_CURRENT_SURFACE, EGL_FALSE);     }       return EGL_TRUE; }

2.7.4 小节

大概再总结下整个过程：

1）首先计算非dirty区域，然后将非dirty区域数据从上一个buffer拷贝到当前buffer；

2）完成buffer内容的填充，然后将previousBuffer指向buffer，同时queue buffer。

3）Dequeue一块新的buffer，并等待fence。如果等待超时，就将buffer cancel掉。

4）按需重新计算buffer

5）Lock buffer，这样就实现page flip，也就是swapbuffer

可以知道，在Dequeue buffer的时候，是有在等待fence的。即便是等待超时，也是需要一个Vsync时间的。

其实在queue buffer的实现函数中，也有等待fence的过程。只有获取到fence之后，调用fb_post进行图形显示。只是这部分是在surfacelinger端。所以不block ui线程。

回到文章开头的问题，调用eglSwapBuffers是需要等待fence的。但是，有一个特别的情况，就是当前dequeue的buffer已经超过了能够申请buffer的最大数，比如说1。这个时候waitForFreeSlotThenRelock()@BufferConsumerProducer就会返回一个错误值：INVALID_OPERATION，。这样的话，eglSwapbuffer就返回一个错误值return setError(EGL_BAD_CURRENT_SURFACE, EGL_FALSE);

所以，这样就有可能出现超过60帧的情况。也就是GPU可以完成超过60帧的绘制，但是最多只能显示60帧。