Android8.0 图形引擎的核心 - BufferQueue
上三篇文章我们弄清了图形引擎的输出和动力泵，今天我们来看图形引擎的心脏。为了呈上启下，我们从SurfaceFlinger的事务处理看BufferQueue如何向SurfaceFlinger提供数据驱动这颗心脏跳动。
从SurfaceFlinger切入来看: SurfaceFlinger在接收到vsync信号后对层级进行更新，RenderEngine对数据进行渲染，HwComposer对数据进行预处理合成，执行swapBuffer()，进一步回调BufferQueueConsumer释放缓冲，驱动BufferQueue运行。
从另一个角度: 在创建Surface的时候会持有IBufferQueueProducer, 在上层View执行draw()函数时会调用Surface的unlockAndPost函数，Surface的IBufferQueueProducer接口下的queueBuffer()函数，进而驱动BufferQueue的queueBuffer(), 进一步执行onFrameAvailable()回调函数，最后输出到帧缓冲驱动FB。
1. SurfaceFlinger事务处理
frameworks\native\services\surfaceflinger\SurfaceFlinger.cpp
同步信号将驱动onMessageReceived()执行事务处理
void SurfaceFlinger::onMessageReceived(int32_t what) {
ATRACE_CALL();
switch (what) {
case MessageQueue::INVALIDATE: {
bool frameMissed = !mHadClientComposition &&
mPreviousPresentFence != Fence::NO_FENCE &&
(mPreviousPresentFence->getSignalTime() ==
Fence::SIGNAL_TIME_PENDING);
ATRACE_INT("FrameMissed", static_cast<int>(frameMissed));
if (mPropagateBackpressure && frameMissed) {
ALOGD("Backpressure trigger, skipping transaction & refresh!");
signalLayerUpdate(); //层级更新
break;
}
// Now that we're going to make it to the handleMessageTransaction()
// call below it's safe to call updateVrFlinger(), which will
// potentially trigger a display handoff.
updateVrFlinger();
bool refreshNeeded = handleMessageTransaction();
refreshNeeded |= handleMessageInvalidate();
refreshNeeded |= mRepaintEverything;
if (refreshNeeded) {
// Signal a refresh if a transaction modified the window state,
// a new buffer was latched, or if HWC has requested a full
// repaint
signalRefresh();
}
break;
}
case MessageQueue::REFRESH: {
handleMessageRefresh();
break;
}
}
frameworks\native\services\surfaceflinger\SurfaceFlinger.cpp
处理ReFresh事件
void SurfaceFlinger::handleMessageRefresh() {
ATRACE_CALL();
nsecs_t refreshStartTime = systemTime(SYSTEM_TIME_MONOTONIC);
preComposition(refreshStartTime); //预合成
rebuildLayerStacks(); // 重建层级
setUpHWComposer(); //设置硬件合成
doDebugFlashRegions();
doComposition();//执行合成
postComposition(refreshStartTime);//提交合成事务
mPreviousPresentFence = mHwc->getPresentFence(HWC_DISPLAY_PRIMARY);
mHadClientComposition = false;
for (size_t displayId = 0; displayId < mDisplays.size(); ++displayId) {
const sp<DisplayDevice>& displayDevice = mDisplays[displayId];
mHadClientComposition = mHadClientComposition ||
mHwc->hasClientComposition(displayDevice->getHwcDisplayId());
}
mLayersWithQueuedFrames.clear();
}
frameworks\native\services\surfaceflinger\SurfaceFlinger.cpp
对层级进行优先级排序重建
void SurfaceFlinger::rebuildLayerStacks() {
ATRACE_CALL();
ALOGV("rebuildLayerStacks");
// rebuild the visible layer list per screen
if (CC_UNLIKELY(mVisibleRegionsDirty)) {
ATRACE_CALL();
mVisibleRegionsDirty = false;
invalidateHwcGeometry();
for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { //对所有显示屏处理
Region opaqueRegion;
Region dirtyRegion;
Vector<sp<Layer>> layersSortedByZ;
const sp<DisplayDevice>& displayDevice(mDisplays[dpy]);
const Transform& tr(displayDevice->getTransform());
const Rect bounds(displayDevice->getBounds());
if (displayDevice->isDisplayOn()) { //显示屏处于开启状态
computeVisibleRegions( //计算可见区域
displayDevice->getLayerStack(), dirtyRegion,
opaqueRegion);
//按Z序列进行排序
mDrawingState.traverseInZOrder([&](Layer* layer) {
if (layer->getLayerStack() == displayDevice->getLayerStack()) {
Region drawRegion(tr.transform(
layer->visibleNonTransparentRegion));
drawRegion.andSelf(bounds);
if (!drawRegion.isEmpty()) {
layersSortedByZ.add(layer);
} else {
// Clear out the HWC layer if this layer was
// previously visible, but no longer is
layer->setHwcLayer(displayDevice->getHwcDisplayId(),
nullptr);
}
} else {
// WM changes displayDevice->layerStack upon sleep/awake.
// Here we make sure we delete the HWC layers even if
// WM changed their layer stack.
layer->setHwcLayer(displayDevice->getHwcDisplayId(),
nullptr);
}
});
}
displayDevice->setVisibleLayersSortedByZ(layersSortedByZ); //可见Layers
displayDevice->undefinedRegion.set(bounds);
displayDevice->undefinedRegion.subtractSelf(
tr.transform(opaqueRegion));
displayDevice->dirtyRegion.orSelf(dirtyRegion);
}
}
}
frameworks\native\services\surfaceflinger\SurfaceFlinger.cpp
对图像数据进行合成处理
void SurfaceFlinger::doComposition() {
ATRACE_CALL();
ALOGV("doComposition");
const bool repaintEverything = android_atomic_and(0, &mRepaintEverything);
for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { //遍历所有显示屏
const sp<DisplayDevice>& hw(mDisplays[dpy]);
if (hw->isDisplayOn()) { //显示屏已开启
// transform the dirty region into this screen's coordinate space
const Region dirtyRegion(hw->getDirtyRegion(repaintEverything));
// repaint the framebuffer (if needed)
doDisplayComposition(hw, dirtyRegion);
hw->dirtyRegion.clear();
hw->flip(hw->swapRegion);
hw->swapRegion.clear();
}
}
postFramebuffer(); //提交
}
frameworks\native\services\surfaceflinger\SurfaceFlinger.cpp
图形数据渲染，交给双缓冲或三缓冲处理
void SurfaceFlinger::doDisplayComposition(
const sp<const DisplayDevice>& displayDevice,
const Region& inDirtyRegion)
{
// We only need to actually compose the display if:
// 1) It is being handled by hardware composer, which may need this to
// keep its virtual display state machine in sync, or
// 2) There is work to be done (the dirty region isn't empty)
bool isHwcDisplay = displayDevice->getHwcDisplayId() >= 0;
if (!isHwcDisplay && inDirtyRegion.isEmpty()) {
ALOGV("Skipping display composition");
return;
}
ALOGV("doDisplayComposition");
Region dirtyRegion(inDirtyRegion);
// compute the invalid region
displayDevice->swapRegion.orSelf(dirtyRegion);
uint32_t flags = displayDevice->getFlags();
if (flags & DisplayDevice::SWAP_RECTANGLE) {
// we can redraw only what's dirty, but since SWAP_RECTANGLE only
// takes a rectangle, we must make sure to update that whole
// rectangle in that case
dirtyRegion.set(displayDevice->swapRegion.bounds());
} else {
if (flags & DisplayDevice::PARTIAL_UPDATES) {
// We need to redraw the rectangle that will be updated
// (pushed to the framebuffer).
// This is needed because PARTIAL_UPDATES only takes one
// rectangle instead of a region (see DisplayDevice::flip())
dirtyRegion.set(displayDevice->swapRegion.bounds());
} else {
// we need to redraw everything (the whole screen)
dirtyRegion.set(displayDevice->bounds());
displayDevice->swapRegion = dirtyRegion;
}
}
//交由RenderEngine处理
if (!doComposeSurfaces(displayDevice, dirtyRegion)) return;
// update the swap region and clear the dirty region
displayDevice->swapRegion.orSelf(dirtyRegion);
// swap buffers (presentation)
displayDevice->swapBuffers(getHwComposer()); //终于执行缓冲交换
}
frameworks\native\services\surfaceflinger\SurfaceFlinger.cpp
提交帧缓冲
void SurfaceFlinger::postFramebuffer()
{
ATRACE_CALL();
ALOGV("postFramebuffer");
const nsecs_t now = systemTime();
mDebugInSwapBuffers = now;
for (size_t displayId = 0; displayId < mDisplays.size(); ++displayId) {
auto& displayDevice = mDisplays[displayId];
if (!displayDevice->isDisplayOn()) {
continue;
}
const auto hwcId = displayDevice->getHwcDisplayId();
if (hwcId >= 0) {
mHwc->presentAndGetReleaseFences(hwcId);
}
displayDevice->onSwapBuffersCompleted(); //处理缓冲交换完成
displayDevice->makeCurrent(mEGLDisplay, mEGLContext);
for (auto& layer : displayDevice->getVisibleLayersSortedByZ()) {
sp<Fence> releaseFence = Fence::NO_FENCE;
if (layer->getCompositionType(hwcId) == HWC2::Composition::Client) {
releaseFence = displayDevice->getClientTargetAcquireFence();
} else {
auto hwcLayer = layer->getHwcLayer(hwcId);
releaseFence = mHwc->getLayerReleaseFence(hwcId, hwcLayer);
}
layer->onLayerDisplayed(releaseFence);
}
if (hwcId >= 0) {
mHwc->clearReleaseFences(hwcId);
}
}
mLastSwapBufferTime = systemTime() - now;
mDebugInSwapBuffers = 0;
// |mStateLock| not needed as we are on the main thread
uint32_t flipCount = getDefaultDisplayDeviceLocked()->getPageFlipCount();
if (flipCount % LOG_FRAME_STATS_PERIOD == 0) {
logFrameStats();
}
}
frameworks\native\services\surfaceflinger\DisplayDevice.cpp
帧缓冲完成回调
#ifdef USE_HWC2
void DisplayDevice::onSwapBuffersCompleted() const {
mDisplaySurface->onFrameCommitted();
}
#else
void DisplayDevice::onSwapBuffersCompleted(HWComposer& hwc) const {
if (hwc.initCheck() == NO_ERROR) {
mDisplaySurface->onFrameCommitted();
}
}
#endif
frameworks\native\services\surfaceflinger\DisplayHardware\FramebufferSurface.cpp
继续回调，执行缓冲释放
void FramebufferSurface::onFrameCommitted() {
#ifdef USE_HWC2
if (mHasPendingRelease) {
sp<Fence> fence = mHwc.getPresentFence(mDisplayType);
if (fence->isValid()) {
status_t result = addReleaseFence(mPreviousBufferSlot,
mPreviousBuffer, fence);
ALOGE_IF(result != NO_ERROR, "onFrameCommitted: failed to add the"
" fence: %s (%d)", strerror(-result), result);
}
status_t result = releaseBufferLocked(mPreviousBufferSlot,
mPreviousBuffer, EGL_NO_DISPLAY, EGL_NO_SYNC_KHR);
ALOGE_IF(result != NO_ERROR, "onFrameCommitted: error releasing buffer:"
" %s (%d)", strerror(-result), result);
mPreviousBuffer.clear();
mHasPendingRelease = false;
}
#else
sp<Fence> fence = mHwc.getAndResetReleaseFence(mDisplayType);
if (fence->isValid() &&
mCurrentBufferSlot != BufferQueue::INVALID_BUFFER_SLOT) {
status_t err = addReleaseFence(mCurrentBufferSlot,
mCurrentBuffer, fence);
ALOGE_IF(err, "setReleaseFenceFd: failed to add the fence: %s (%d)",
strerror(-err), err);
}
#endif
}
frameworks\native\libs\gui\ConsumerBase.cpp
回调监听顶层控制类，调用BufferQueueConsumer的releaseBuffer函数驱动BufferQueue继续同步执行
status_t ConsumerBase::releaseBufferLocked(
int slot, const sp<GraphicBuffer> graphicBuffer,
EGLDisplay display, EGLSyncKHR eglFence) {
if (mAbandoned) {
CB_LOGE("releaseBufferLocked: ConsumerBase is abandoned!");
return NO_INIT;
}
// If consumer no longer tracks this graphicBuffer (we received a new
// buffer on the same slot), the buffer producer is definitely no longer
// tracking it.
if (!stillTracking(slot, graphicBuffer)) {
return OK;
}
CB_LOGV("releaseBufferLocked: slot=%d/%" PRIu64,
slot, mSlots[slot].mFrameNumber);
status_t err = mConsumer->releaseBuffer(slot, mSlots[slot].mFrameNumber, //调用缓冲释放
display, eglFence, mSlots[slot].mFence);
if (err == IGraphicBufferConsumer::STALE_BUFFER_SLOT) {
freeBufferLocked(slot);
}
mPrevFinalReleaseFence = mSlots[slot].mFence;
mSlots[slot].mFence = Fence::NO_FENCE;
return err;
}
2. Surface创建与BufferQueue驱动
窗体管理服务(WMS)通过SurfaceComposerClient创建Client与SurfaceFlinger交互，WMS负责窗体界面的优先级排序，剪切，层级管理等，SurfaceFlinger进行图形数据的合成，Gralloc负责将合成的数据输出到硬件。
sp<SurfaceControl> SurfaceComposerClient::createSurface(
const String8& name,
uint32_t w,
uint32_t h,
PixelFormat format,
uint32_t flags,
SurfaceControl* parent,
uint32_t windowType,
uint32_t ownerUid)
{
sp<SurfaceControl> sur;
if (mStatus == NO_ERROR) {
sp<IBinder> handle;
sp<IBinder> parentHandle;
sp<IGraphicBufferProducer> gbp;
if (parent != nullptr) {
parentHandle = parent->getHandle();
}
// mClient 是 ISurfaceComposerClient
status_t err = mClient->createSurface(name, w, h, format, flags, parentHandle,
windowType, ownerUid, &handle, &gbp);
ALOGE_IF(err, "SurfaceComposerClient::createSurface error %s", strerror(-err));
if (err == NO_ERROR) {
sur = new SurfaceControl(this, handle, gbp); //控制Surface的创建,gbp将由上述createSurface返回
}
}
return sur;
}
Binder顶层协议ISurfaceComposerClient的Bn端为Client.cpp
status_t Client::createSurface(
const String8& name,
uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
const sp<IBinder>& parentHandle, uint32_t windowType, uint32_t ownerUid,
sp<IBinder>* handle,
sp<IGraphicBufferProducer>* gbp)
{
......
class MessageCreateLayer : public MessageBase {
SurfaceFlinger* flinger;
Client* client;
sp<IBinder>* handle;
sp<IGraphicBufferProducer>* gbp; //生产者
status_t result;
const String8& name;
uint32_t w, h;
PixelFormat format;
uint32_t flags;
sp<Layer>* parent;
uint32_t windowType;
uint32_t ownerUid;
public:
MessageCreateLayer(SurfaceFlinger* flinger,
const String8& name, Client* client,
uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
sp<IBinder>* handle, uint32_t windowType, uint32_t ownerUid,
sp<IGraphicBufferProducer>* gbp,
sp<Layer>* parent)
: flinger(flinger), client(client),
handle(handle), gbp(gbp), result(NO_ERROR),
name(name), w(w), h(h), format(format), flags(flags),
parent(parent), windowType(windowType), ownerUid(ownerUid) {
}
status_t getResult() const { return result; }
virtual bool handler() { //将由init启动调用
result = flinger->createLayer(name, client, w, h, format, flags,
windowType, ownerUid, handle, gbp, parent);
return true;
}
};
sp<MessageBase> msg = new MessageCreateLayer(mFlinger.get(),
name, this, w, h, format, flags, handle,
windowType, ownerUid, gbp, &parent);
mFlinger->postMessageSync(msg);
return static_cast<MessageCreateLayer*>( msg.get() )->getResult();
}
frameworks\native\services\surfaceflinger\SurfaceFlinger.cpp
创建图形Layer
status_t SurfaceFlinger::createLayer(
const String8& name,
const sp<Client>& client,
uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
uint32_t windowType, uint32_t ownerUid, sp<IBinder>* handle,
sp<IGraphicBufferProducer>* gbp, sp<Layer>* parent)
{
switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
case ISurfaceComposerClient::eFXSurfaceNormal:
result = createNormalLayer(client, //创建普通Layer
uniqueName, w, h, flags, format,
handle, gbp, &layer);
break;
case ISurfaceComposerClient::eFXSurfaceDim:
result = createDimLayer(client, //创建虚化Layer
uniqueName, w, h, flags,
handle, gbp, &layer);
break;
default:
result = BAD_VALUE;
break;
}
layer->setInfo(windowType, ownerUid);
result = addClientLayer(client, *handle, *gbp, layer, *parent);
if (result != NO_ERROR) {
return result;
}
mInterceptor.saveSurfaceCreation(layer); //暂存
setTransactionFlags(eTransactionNeeded);
return result;
}
frameworks\native\services\surfaceflinger\SurfaceFlinger.cpp
创建通用型Layer,初始化Surface
status_t SurfaceFlinger::createNormalLayer(const sp<Client>& client,
const String8& name, uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format,
sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
{
// initialize the surfaces
switch (format) {
case PIXEL_FORMAT_TRANSPARENT:
case PIXEL_FORMAT_TRANSLUCENT:
format = PIXEL_FORMAT_RGBA_8888;
break;
case PIXEL_FORMAT_OPAQUE:
format = PIXEL_FORMAT_RGBX_8888;
break;
}
*outLayer = new Layer(this, client, name, w, h, flags);
status_t err = (*outLayer)->setBuffers(w, h, format, flags);
if (err == NO_ERROR) {
*handle = (*outLayer)->getHandle();
*gbp = (*outLayer)->getProducer(); //获取IGraphicBufferProducer，返回一个mProducer
}
ALOGE_IF(err, "createNormalLayer() failed (%s)", strerror(-err));
return err;
}
frameworks\native\services\surfaceflinger\Layer.cpp
在创建Layer的时候会创建BufferQueue
void Layer::onFirstRef() {
// Creates a custom BufferQueue for SurfaceFlingerConsumer to use
sp<IGraphicBufferProducer> producer; //生产者
sp<IGraphicBufferConsumer> consumer;//消费者
BufferQueue::createBufferQueue(&producer, &consumer, true); //BufferQueue同时持有通讯接口
mProducer = new MonitoredProducer(producer, mFlinger, this); //提供mProducer
mSurfaceFlingerConsumer = new SurfaceFlingerConsumer(consumer, mTextureName, this); //负责同步数据输出
mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0));
mSurfaceFlingerConsumer->setContentsChangedListener(this);
mSurfaceFlingerConsumer->setName(mName);
if (mFlinger->isLayerTripleBufferingDisabled()) {
mProducer->setMaxDequeuedBufferCount(2); //设置缓冲槽数量
}
const sp<const DisplayDevice> hw(mFlinger->getDefaultDisplayDevice()); //获取默认显示设备
updateTransformHint(hw);
}
frameworks\native\libs\gui\BufferQueue.cpp
创建缓冲队列，初始化BufferQueueCore
void BufferQueue::createBufferQueue(sp<IGraphicBufferProducer>* outProducer,
sp<IGraphicBufferConsumer>* outConsumer,
bool consumerIsSurfaceFlinger) {
sp<BufferQueueCore> core(new BufferQueueCore()); //创建BufferQueueCore
//BufferQueueProducer 是IGraphicBufferProducer的 Bn端 负责缓冲数据的出入队列
sp<IGraphicBufferProducer> producer(new BufferQueueProducer(core, consumerIsSurfaceFlinger));
////BufferQueueConsumer 是IGraphicBufferConsumer的 Bn端 负责缓冲数据的锁定释放
sp<IGraphicBufferConsumer> consumer(new BufferQueueConsumer(core));
//持有
*outProducer = producer;
*outConsumer = consumer;
}
frameworks\native\libs\gui\SurfaceControl.cpp
提供Surface创建函数
sp<Surface> SurfaceControl::createSurface() const
{
Mutex::Autolock _l(mLock);
return generateSurfaceLocked();
}
sp<Surface> SurfaceControl::generateSurfaceLocked() const
{
// This surface is always consumed by SurfaceFlinger, so the
// producerControlledByApp value doesn't matter; using false.
mSurfaceData = new Surface(mGraphicBufferProducer, false);
//mGraphicBufferProducer由SurfaceControl构造函数传入
return mSurfaceData;
}
frameworks\native\services\surfaceflinger\SurfaceFlinger.cpp
创建默认的显示设备
void SurfaceFlinger::createDefaultDisplayDevice() {
const int32_t type = DisplayDevice::DISPLAY_PRIMARY;
wp<IBinder> token = mBuiltinDisplays[type]; //内建显示设备
// All non-virtual displays are currently considered secure.
const bool isSecure = true;
//创建BufferQueue
sp<IGraphicBufferProducer> producer;
sp<IGraphicBufferConsumer> consumer;
BufferQueue::createBufferQueue(&producer, &consumer);
//创建缓冲数据输出控制
sp<FramebufferSurface> fbs = new FramebufferSurface(*c, type, consumer);
bool hasWideColorModes = false;
//查询颜色模式
std::vector<android_color_mode_t> modes = getHwComposer().getColorModes(type);
for (android_color_mode_t colorMode : modes) {
switch (colorMode) {
case HAL_COLOR_MODE_DISPLAY_P3:
case HAL_COLOR_MODE_ADOBE_RGB:
case HAL_COLOR_MODE_DCI_P3:
hasWideColorModes = true;
break;
default:
break;
}
}
//新建显示设备
sp<DisplayDevice> hw = new DisplayDevice(this, DisplayDevice::DISPLAY_PRIMARY, type, isSecure,
token, fbs, producer, mRenderEngine->getEGLConfig(),
hasWideColorModes && hasWideColorDisplay);
//管理显示设备
mDisplays.add(token, hw);
android_color_mode defaultColorMode = HAL_COLOR_MODE_NATIVE;
if (hasWideColorModes && hasWideColorDisplay) {
defaultColorMode = HAL_COLOR_MODE_SRGB;
}
setActiveColorModeInternal(hw, defaultColorMode);
}
frameworks\native\services\surfaceflinger\DisplayDevice.cpp
创建了一个Surface, 接收图像数据渲染信号，通过FramebufferSurface进一步处理，同时协调HWComposer
// clang-format off
DisplayDevice::DisplayDevice(
const sp<SurfaceFlinger>& flinger,
DisplayType type,
int32_t hwcId,
#ifndef USE_HWC2
int format,
#endif
bool isSecure,
const wp<IBinder>& displayToken,
const sp<DisplaySurface>& displaySurface,
const sp<IGraphicBufferProducer>& producer,
EGLConfig config,
bool supportWideColor)
: lastCompositionHadVisibleLayers(false),
mFlinger(flinger),
mType(type),
mHwcDisplayId(hwcId),
mDisplayToken(displayToken),
mDisplaySurface(displaySurface), //FramebufferSurface
mDisplay(EGL_NO_DISPLAY),
mSurface(EGL_NO_SURFACE),
mDisplayWidth(),
mDisplayHeight(),
#ifndef USE_HWC2
mFormat(),
#endif
mFlags(),
mPageFlipCount(),
mIsSecure(isSecure),
mLayerStack(NO_LAYER_STACK),
mOrientation(),
mPowerMode(HWC_POWER_MODE_OFF),
mActiveConfig(0)
{
// clang-format on
Surface* surface;
mNativeWindow = surface = new Surface(producer, false); //新建Surface，传入producer，同SurfaceControl
ANativeWindow* const window = mNativeWindow.get();
......
if (useTripleFramebuffer) {
surface->allocateBuffers(); //分配缓冲
}
}
frameworks\native\services\surfaceflinger\DisplayDevice.cpp
交换函数swapBuffers，对缓冲数据预填充
void DisplayDevice::swapBuffers(HWComposer& hwc) const {
#ifdef USE_HWC2
if (hwc.hasClientComposition(mHwcDisplayId)) {
#else
// We need to call eglSwapBuffers() if:
// (1) we don't have a hardware composer, or
// (2) we did GLES composition this frame, and either
// (a) we have framebuffer target support (not present on legacy
// devices, where HWComposer::commit() handles things); or
// (b) this is a virtual display
if (hwc.initCheck() != NO_ERROR ||
(hwc.hasGlesComposition(mHwcDisplayId) &&
(hwc.supportsFramebufferTarget() || mType >= DISPLAY_VIRTUAL))) {
#endif
EGLBoolean success = eglSwapBuffers(mDisplay, mSurface);
if (!success) {
EGLint error = eglGetError();
if (error == EGL_CONTEXT_LOST ||
mType == DisplayDevice::DISPLAY_PRIMARY) {
LOG_ALWAYS_FATAL("eglSwapBuffers(%p, %p) failed with 0x%08x",
mDisplay, mSurface, error);
} else {
ALOGE("eglSwapBuffers(%p, %p) failed with 0x%08x",
mDisplay, mSurface, error);
}
}
}
status_t result = mDisplaySurface->advanceFrame(); //调用 FramebufferSurface
if (result != NO_ERROR) {
ALOGE("[%s] failed pushing new frame to HWC: %d",
mDisplayName.string(), result);
}
}
frameworks\native\services\surfaceflinger\DisplayHardware\FramebufferSurface.cpp
这是帧缓冲稳定回掉，由生产者调用，最终将数据送到帧缓冲驱动
#ifndef USE_HWC2
// Overrides ConsumerBase::onFrameAvailable(), does not call base class impl.
void FramebufferSurface::onFrameAvailable(const BufferItem& /* item */) {
sp<GraphicBuffer> buf;
sp<Fence> acquireFence;
status_t err = nextBuffer(buf, acquireFence); //请求下一帧
if (err != NO_ERROR) {
ALOGE("error latching nnext FramebufferSurface buffer: %s (%d)",
strerror(-err), err);
return;
}
err = mHwc.fbPost(mDisplayType, acquireFence, buf); //数据输出
if (err != NO_ERROR) {
ALOGE("error posting framebuffer: %d", err);
}
}
#endif
frameworks\native\services\surfaceflinger\Layer.cpp
Layer层同样存在一个onFrameAvailable, 更新Layer层级
void Layer::onFrameAvailable(const BufferItem& item) {
// Add this buffer from our internal queue tracker
{ // Autolock scope
Mutex::Autolock lock(mQueueItemLock);
mFlinger->mInterceptor.saveBufferUpdate(this, item.mGraphicBuffer->getWidth(),
item.mGraphicBuffer->getHeight(), item.mFrameNumber);
// Reset the frame number tracker when we receive the first buffer after
// a frame number reset
if (item.mFrameNumber == 1) {
mLastFrameNumberReceived = 0;
}
// Ensure that callbacks are handled in order
while (item.mFrameNumber != mLastFrameNumberReceived + 1) {
status_t result = mQueueItemCondition.waitRelative(mQueueItemLock,
ms2ns(500));
if (result != NO_ERROR) {
ALOGE("[%s] Timed out waiting on callback", mName.string());
}
}
mQueueItems.push_back(item);
android_atomic_inc(&mQueuedFrames);
// Wake up any pending callbacks
mLastFrameNumberReceived = item.mFrameNumber;
mQueueItemCondition.broadcast();
}
mFlinger->signalLayerUpdate();
}
frameworks\native\libs\gui\BufferQueueProducer.cpp
在BufferQueueProducer的queueBuffer函数中调用了onFrameAvailable
status_t BufferQueueProducer::queueBuffer(int slot,
const QueueBufferInput &input, QueueBufferOutput *output) {
......
sp<IConsumerListener> frameAvailableListener;
sp<IConsumerListener> frameReplacedListener;
.......
{ // scope for the lock
Mutex::Autolock lock(mCallbackMutex);
while (callbackTicket != mCurrentCallbackTicket) {
mCallbackCondition.wait(mCallbackMutex);
}
if (frameAvailableListener != NULL) {
frameAvailableListener->onFrameAvailable(item); //执行回调
} else if (frameReplacedListener != NULL) {
frameReplacedListener->onFrameReplaced(item);
}
}
......
return NO_ERROR;
}
frameworks\native\libs\gui\Surface.cpp
终于，找到熟悉的函数，unlockAndPost()在View绘制的时候会被调用，以后再讲
status_t Surface::unlockAndPost()
{
if (mLockedBuffer == 0) {
ALOGE("Surface::unlockAndPost failed, no locked buffer");
return INVALID_OPERATION;
}
int fd = -1;
status_t err = mLockedBuffer->unlockAsync(&fd);
ALOGE_IF(err, "failed unlocking buffer (%p)", mLockedBuffer->handle);
err = queueBuffer(mLockedBuffer.get(), fd); //缓冲入队
ALOGE_IF(err, "queueBuffer (handle=%p) failed (%s)",
mLockedBuffer->handle, strerror(-err));
mPostedBuffer = mLockedBuffer;
mLockedBuffer = 0;
return err;
}
至此我们留下了两个伏笔一个是SurfaceComposerClient如何与WMS对接创建Surface, Surface如何与View关联，这是两个重要的地方，下一篇我们将从Activity的onCreate()函数开始从上往下，经过Window，WindowManager, WindowManagerService, 跨越式看App和Activity如何与图形引擎对接。