20181220_eglSwapBuffers详解

77 阅读 0 评论 51 点赞

我是靠谱客的博主勤奋芹菜，最近开发中收集的这篇文章主要介绍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);