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帧。