Android P 显示流程分析（四）---界面刷新

最新推荐文章于 2024-05-05 14:21:09 发布
最新推荐文章于 2024-05-05 14:21:09 发布
阅读量1.5k 收藏 7
点赞数 1
文章标签： android c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tovey2008/article/details/113479609
版权

SurfaceFlinger 硬件合成 HWC Composition类型 图层处理
关键词由CSDN通过智能技术生成

上篇分析到SurfaceFlinger.signalRefresh()里会调用到SurfaceFlinger里的handleMessageRefresh(), 现在这里面开始涉及到图层合成了，这里面涉及的流程。

handleMessageRefresh()

void SurfaceFlinger::handleMessageRefresh() {
    mRefreshPending = false;
    nsecs_t refreshStartTime = systemTime(SYSTEM_TIME_MONOTONIC);
	//合成图像前的准备工作，设置各种状态
    preComposition(refreshStartTime);
    //重建可见区域的所有图层
    rebuildLayerStacks();
    //启动硬件图像合成
    setUpHWComposer();
    //调试信息
    doDebugFlashRegions();
    doTracing("handleRefresh");
    logLayerStats();
    //合成处理
    doComposition();
    //更新状态与下次合成时间
    postComposition(refreshStartTime);
}

上面重点的就是两块，一个setupHWComposer() 启动硬件图像合成, 另一个是doComposition()合成处理。

setUpHWComposer()

void SurfaceFlinger::setUpHWComposer() {
...
    if (CC_UNLIKELY(mGeometryInvalid)) {
        mGeometryInvalid = false;
        //遍历所有的显示设备
        for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
            sp<const DisplayDevice> displayDevice(mDisplays[dpy]);
            const auto hwcId = displayDevice->getHwcDisplayId();
            if (hwcId >= 0) {
                const Vector<sp<Layer>>& currentLayers(
                        displayDevice->getVisibleLayersSortedByZ());
                //遍历当前显示设备的所有图层
                for (size_t i = 0; i < currentLayers.size(); i++) {
                    const auto& layer = currentLayers[i];
                    if (!layer->hasHwcLayer(hwcId)) {
                    	//如果没有硬件图层，则创建一个硬件图层
                        if (!layer->createHwcLayer(getBE().mHwc.get(), hwcId)) {
                            layer->forceClientComposition(hwcId);
                            continue;
                        }
                    }
					//设置图层大小，坐标
                    layer->setGeometry(displayDevice, i);
                    if (mDebugDisableHWC || mDebugRegion) {
                        layer->forceClientComposition(hwcId);
                    }
                }
            }
        }
    // Set the per-frame data
    //遍历所有显示屏
    for (size_t displayId = 0; displayId < mDisplays.size(); ++displayId) {
        auto& displayDevice = mDisplays[displayId];
        const auto hwcId = displayDevice->getHwcDisplayId();

        if (hwcId < 0) {
            continue;
        }
        //更新颜色变化
        if (mDrawingState.colorMatrixChanged) {
            displayDevice->setColorTransform(mDrawingState.colorMatrix);
            status_t result = getBE().mHwc->setColorTransform(hwcId, mDrawingState.colorMatrix);
            ALOGE_IF(result != NO_ERROR, "Failed to set color transform on "
                    "display %zd: %d", displayId, result);
        }
        //遍历当前显示屏的所有图层
        for (auto& layer : displayDevice->getVisibleLayersSortedByZ()) {
        	//设置数据存储格式
            if (layer->isHdrY410()) {
                layer->forceClientComposition(hwcId);
            } else if ((layer->getDataSpace() == Dataspace::BT2020_PQ ||
                        layer->getDataSpace() == Dataspace::BT2020_ITU_PQ) &&
                    !displayDevice->hasHDR10Support()) {
                layer->forceClientComposition(hwcId);
            } else if ((layer->getDataSpace() == Dataspace::BT2020_HLG ||
                        layer->getDataSpace() == Dataspace::BT2020_ITU_HLG) &&
                    !displayDevice->hasHLGSupport()) {
                layer->forceClientComposition(hwcId);
            }
			//设置图层合成类型
            if (layer->getForceClientComposition(hwcId)) {
                ALOGV("[%s] Requesting Client composition", layer->getName().string());
                layer->setCompositionType(hwcId, HWC2::Composition::Client);
                continue;
            }
			//图层的数据设置到显示器
            layer->setPerFrameData(displayDevice);
        }
		//设置颜色模式
        if (hasWideColorDisplay) {
            ColorMode colorMode;
            Dataspace dataSpace;
            RenderIntent renderIntent;
            pickColorMode(displayDevice, &colorMode, &dataSpace, &renderIntent);
            setActiveColorModeInternal(displayDevice, colorMode, dataSpace, renderIntent);
        }
    } 
    mDrawingState.colorMatrixChanged = false;
	//遍历所有显示屏设备，做了prepareFrame
    for (size_t displayId = 0; displayId < mDisplays.size(); ++displayId) {
        auto& displayDevice = mDisplays[displayId];
        if (!displayDevice->isDisplayOn()) {
            continue;
        }

        status_t result = displayDevice->prepareFrame(*getBE().mHwc);
        ALOGE_IF(result != NO_ERROR, "prepareFrame for display %zd failed:"
                " %d (%s)", displayId, result, strerror(-result));
    }       
    }

因为setUpHWComposer（）里做的事情很多，我们一个一个来撸下：

  1. layer->createHwcLayer(getBE().mHwc.get(), hwcId)

    --> HWComposer->createLayer(hwcId)

按照我们《Android P 显示流程（一）—Display设备初始化过程分析》
后续最终会调用到HWC2On1Adapter里的createLayer的方法：

Error HWC2On1Adapter::Display::createLayer(hwc2_layer_t* outLayerId) {
    std::unique_lock<std::recursive_mutex> lock(mStateMutex);
	//通过当前Display对象，创建一个新的layer对象，最后添加到mLayers 容器中
    auto layer = *mLayers.emplace(std::make_shared<Layer>(*this));
    mDevice.mLayers.emplace(std::make_pair(layer->getId(), layer));
    *outLayerId = layer->getId();
    ALOGV("[%" PRIu64 "] created layer %" PRIu64, mId, *outLayerId);
    markGeometryChanged();
    return Error::None;
}

  1. layer->setGeometry(displayDevice, i)
    设置图层大小和坐标位置，这个不是重点，我们就不往下分析了，后面更新颜色矩阵变化也直接跳过

  2. 后面有遍历显示屏的所有图层，设置数据存储格式也跳过不研究，来看看设置合成类型。

void Layer::setCompositionType(int32_t hwcId, HWC2::Composition type, bool callIntoHwc) {
    auto& hwcInfo = getBE().mHwcLayers[hwcId];
    auto& hwcLayer = hwcInfo.layer;	
    //判读与目前此图层的合成类型是否一致，如果不一致，更改合成类型
    if (hwcInfo.compositionType != type) {
        ALOGV("    actually setting");
        hwcInfo.compositionType = type;
        if (callIntoHwc) {
            auto error = hwcLayer->setCompositionType(type);
        }
    }
}
Error Layer::setCompositionType(Composition type)
{
    auto intType = static_cast<Hwc2::IComposerClient::Composition>(type);
    auto intError = mComposer.setLayerCompositionType(
            mDisplayId, mId, intType);
    return static_cast<Error>(intError);
}
//同之前分析的流程，最后会调用到HWC2On1Adapter里面
Error HWC2On1Adapter::Layer::setCompositionType(Composition type)
{
    mCompositionType.setPending(type);
    return Error::None;
}

这个设置图层的类型，那图层到底有哪些类型呢？

  • Composition::Client
  • Composition::Device
  • Composition::SolidColor
  • Composition::Cursor
  • Composition::Sideband
    上面这几种Composition 类型到底有什么区别呢，看看applyCompositionType:
void HWC2On1Adapter::Layer::applyCompositionType(hwc_layer_1_t& hwc1Layer,
        bool applyAllState)
{
    // HWC1 never supports color transforms or dataspaces and only sometimes
    // supports plane alpha (depending on the version). These require us to drop
    // some or all layers to client composition.
    if (mHasUnsupportedDataspace || mHasUnsupportedPlaneAlpha ||
            mDisplay.hasColorTransform()) {
        hwc1Layer.compositionType = HWC_FRAMEBUFFER;
        hwc1Layer.flags = HWC_SKIP_LAYER;
        return;
    }

    if (applyAllState || mCompositionType.isDirty()) {
        hwc1Layer.flags = 0;
        switch (mCompositionType.getPendingValue()) {
            case Composition::Client:
                hwc1Layer.compositionType = HWC_FRAMEBUFFER;
                hwc1Layer.flags |= HWC_SKIP_LAYER;
                break;
            case Composition::Device:
                hwc1Layer.compositionType = HWC_FRAMEBUFFER;
                break;
            case Composition::SolidColor:
                // In theory the following line should work, but since the HWC1
                // version of SurfaceFlinger never used HWC_BACKGROUND, HWC1
                // devices may not work correctly. To be on the safe side, we
                // fall back to client composition.
                //
                // hwc1Layer.compositionType = HWC_BACKGROUND;
                hwc1Layer.compositionType = HWC_FRAMEBUFFER;
                hwc1Layer.flags |= HWC_SKIP_LAYER;
                break;
            case Composition::Cursor:
                hwc1Layer.compositionType = HWC_FRAMEBUFFER;
                if (mDisplay.getDevice().getHwc1MinorVersion() >= 4) {
                    hwc1Layer.hints |= HWC_IS_CURSOR_LAYER;
                }
                break;
            case Composition::Sideband:
                if (mDisplay.getDevice().getHwc1MinorVersion() < 4) {
                    hwc1Layer.compositionType = HWC_SIDEBAND;
                } else {
                    hwc1Layer.compositionType = HWC_FRAMEBUFFER;
                    hwc1Layer.flags |= HWC_SKIP_LAYER;
                }
                break;
            default:
                hwc1Layer.compositionType = HWC_FRAMEBUFFER;
                hwc1Layer.flags |= HWC_SKIP_LAYER;
                break;
        }
        ALOGV("Layer %" PRIu64 " %s set to %d", mId,
                to_string(mCompositionType.getPendingValue()).c_str(),
                hwc1Layer.compositionType);
        ALOGV_IF(hwc1Layer.flags & HWC_SKIP_LAYER, "    and skipping");
        mCompositionType.latch();
    }
}

这几种虽然不一样，但对应的hwc1Layer.compositionType都是HWC_FRAMEBUFFER，实际上对应HAL层的实现没什么区别。

  1. 每个图层设置每帧的数据
    layer->setPerFrameData(displayDevice)
    但图层又分BufferLayer和ColorLayer，这两路图层有什么区别呢？
        const sp<Client>& client,
        uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
        int32_t windowType, int32_t ownerUid, sp<IBinder>* handle,
        sp<IGraphicBufferProducer>* gbp, sp<Layer>* parent)
{
 switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
        case ISurfaceComposerClient::eFXSurfaceNormal:
            result = createBufferLayer(client,
                    uniqueName, w, h, flags, format,
                    handle, gbp, &layer);

            break;
        case ISurfaceComposerClient::eFXSurfaceColor:
            result = createColorLayer(client,
                    uniqueName, w, h, flags,
                    handle, &layer);
            break;
        default:
            result = BAD_VALUE;
            ...

创建图层时，根据Flag 的不同来创建图层的，一种是纯色的，一种是普通数据显示的图层，这里我们一般指的是BufferLayer.
那继续看BufferLayer的setPerFrameData的函数：

void BufferLayer::setPerFrameData(const sp<const DisplayDevice>& displayDevice) {
    // Apply this display's projection's viewport to the visible region
    // before giving it to the HWC HAL.
    const Transform& tr = displayDevice->getTransform();
    const auto& viewport = displayDevice->getViewport();
    Region visible = tr.transform(visibleRegion.intersect(viewport));
    auto hwcId = displayDevice->getHwcDisplayId();
    auto& hwcInfo = getBE().mHwcLayers[hwcId];
    auto& hwcLayer = hwcInfo.layer;
    //设置可见区域
    auto error = hwcLayer->setVisibleRegion(visible);
    if (error != HWC2::Error::None) {
        ALOGE("[%s] Failed to set visible region: %s (%d)", mName.string(),
              to_string(error).c_str(), static_cast<int32_t>(error));
        visible.dump(LOG_TAG);
    }
	//设置损坏区域
    error = hwcLayer->setSurfaceDamage(surfaceDamageRegion);
    if (error != HWC2::Error::None) {
        ALOGE("[%s] Failed to set surface damage: %s (%d)", mName.string(),
              to_string(error).c_str(), static_cast<int32_t>(error));
        surfaceDamageRegion.dump(LOG_TAG);
    }

    //如果是sideband 图层，直接设置sideband流，然后就返回了
    if (getBE().compositionInfo.hwc.sidebandStream.get()) {
        setCompositionType(hwcId, HWC2::Composition::Sideband);
        ALOGV("[%s] Requesting Sideband composition", mName.string());
        error = hwcLayer->setSidebandStream(getBE().compositionInfo.hwc.sidebandStream->handle());
        if (error != HWC2::Error::None) {
            ALOGE("[%s] Failed to set sideband stream %p: %s (%d)", mName.string(),
                  getBE().compositionInfo.hwc.sidebandStream->handle(), to_string(error).c_str(),
                  static_cast<int32_t>(error));
        }
        return;
    }

	//如果是设备或光标图层，设置相对应的CompositionType
    // Device or Cursor layers
    if (mPotentialCursor) {
        ALOGV("[%s] Requesting Cursor composition", mName.string());
        setCompositionType(hwcId, HWC2::Composition::Cursor);
    } else {
        ALOGV("[%s] Requesting Device composition", mName.string());
        setCompositionType(hwcId, HWC2::Composition::Device);
    }
	//设置Dataspace
    ALOGV("setPerFrameData: dataspace = %d", mCurrentDataSpace);
    error = hwcLayer->setDataspace(mCurrentDataSpace);
    if (error != HWC2::Error::None) {
        ALOGE("[%s] Failed to set dataspace %d: %s (%d)", mName.string(), mCurrentDataSpace,
              to_string(error).c_str(), static_cast<int32_t>(error));
    }
	//设置metadata
    const HdrMetadata& metadata = mConsumer->getCurrentHdrMetadata();
    error = hwcLayer->setPerFrameMetadata(displayDevice->getSupportedPerFrameMetadata(), metadata);
    if (error != HWC2::Error::None && error != HWC2::Error::Unsupported) {
        ALOGE("[%s] Failed to set hdrMetadata: %s (%d)", mName.string(),
              to_string(error).c_str(), static_cast<int32_t>(error));
    }
	//获取hwcBuffer
    uint32_t hwcSlot = 0;
    sp<GraphicBuffer> hwcBuffer;
    hwcInfo.bufferCache.getHwcBuffer(getBE().compositionInfo.mBufferSlot,
                                     getBE().compositionInfo.mBuffer, &hwcSlot, &hwcBuffer);
	//根据fence，设置buffer
    auto acquireFence = mConsumer->getCurrentFence();
    error = hwcLayer->setBuffer(hwcSlot, hwcBuffer, acquireFence);
    if (error != HWC2::Error::None) {
        ALOGE("[%s] Failed to set buffer %p: %s (%d)", mName.string(),
              getBE().compositionInfo.mBuffer->handle, to_string(error).c_str(),
              static_cast<int32_t>(error));
    }
}

那重点来看看获取hwcBuffer和设置buffer

void HWComposerBufferCache::getHwcBuffer(int slot,
        const sp<GraphicBuffer>& buffer,
        uint32_t* outSlot, sp<GraphicBuffer>* outBuffer)
{
    if (slot == BufferQueue::INVALID_BUFFER_SLOT || slot < 0) {
        // default to slot 0
        slot = 0;
    }

    if (static_cast<size_t>(slot) >= mBuffers.size()) {
        mBuffers.resize(slot + 1);
    }
    *outSlot = slot;
    if (mBuffers[slot] == buffer) {
        // already cached in HWC, skip sending the buffer
        *outBuffer = nullptr;
    } else {
        *outBuffer = buffer;

        // update cache
        mBuffers[slot] = buffer;
    }
}

获取Buffer 其实就是将buffer指向outBuffer, 将slot 赋值给outSlot, 中间经过了一个mBuffer[]的缓存。

  • 那最后看设置Buffer, setBuffer根据之前的调用链分析会调用到HW2On1Adapter::Layer里的setBuffer.
Error HWC2On1Adapter::Layer::setBuffer(buffer_handle_t buffer,
        int32_t acquireFence) {
    ALOGV("Setting acquireFence to %d for layer %" PRIu64, acquireFence, mId);
    mBuffer.setBuffer(buffer);
    mBuffer.setFence(acquireFence);
    return Error::None;
}

到这里setPerFrameData 这个函数分析完了。

  1. 遍历所有显示屏，displayDevice->prepareFrame(*getBE().mHwc), 这里面针对FrameBufferSurface来做，没有做实际的事情。这个就跳过不分析了。
    到这里setUpHWComposer() 就分析完了，下篇我们来关键的doCompostion().
Give.Me.Five
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
安卓编程问题1
bleuesprit的专栏
07-14 1万+
今天突发奇想做了一个安卓界面的实验。实验的大体思想如下。 1在mainActivity的layout中添加一个button1 2在secondActivity的onCreate中添加一个代码。Button button =(Button) findViewById(R.id.button1); button.setText("dddddddddd");然后在启动主程序实验结果如下
Android图形显示系统——下层显示4：图层合成下（硬件合成器）
weixin_34331102的博客
06-08 827
硬件合成器-HwComposer 使用3D合成，需要大面积的像素混合计算和大量的内存传输（GPU读写GraphicBuffer所需），对GPU和DDR来说是一个巨大的负担。在GPU/DDR重度使用的场景（比如玩游戏），会造成发热、卡顿等。 为了提升性能，减少功耗，可以将合成这个过程交由另一个芯片完成，减轻GPU负担。进一步，直接让这...
android 各位大神这是什么bug,有想法请留言
热门推荐
u014370269的专栏
03-30 1万+
2019-03-30 14:39:04.664 3142-3246/system_process E/LightsService: Light requested not available on this device. 0 2019-03-30 14:39:04.683 2922-3613/? E/BufferQueueProducer: [ColorFade#0] disconnect: n...
Android13 SurfaceFlinger composite(合成)流程分析
最新发布
liuning1985622的博客
05-05 1385
SurfaceFlinger的composite方法，用于将多个窗口的图像进行合成，主要负责对相关要进行上帧的layer进行，识别排序好，然后合成，有hwc合成的会构建对应OutputLayer传递hwc，GPU合成则直接合成，再传递到hwc中，它主要完成以下几个步骤：从队列中获取所有待合成的缓冲区。将这些缓冲区按照一定的顺序进行合成，生成最终的图像。将合成后的图像提交给HWC进行显示。
error 3002 (EGL_BAD_ACCESS)
wyxh_it的博客
10-04 1713
error 3002 (EGL_BAD_ACCESS)错误解决方案
[RK3288][Android6.0] 调试笔记 --- display数据帧的dump
Kris Fei's blog
07-18 2203
Platform: Rockchip OS: Android 6.0 Kernel: 3.10.92步骤： 1. 打开dump功能 hardware/rockchip/hwcomposer/rk_hwcomposer.h #define hwcDumpSurface 1 2. 设置property #setprop sys.dump true 这时logcat中就可以看到dum
Android待机流程分析---锁屏、解锁模块.
04-12
Android待机流程分析---锁屏、解锁模块源码分析+流程分析图
Android-PullLayout.zip_Android-PullLayout_android
09-21
综上所述，"Android-PullLayout.zip"提供了一个实现下拉刷新功能的解决方案，涵盖了UI设计、事件处理、动画效果、性能优化等多个方面，是Android开发者进行界面交互设计时的一个宝贵资源。通过深入研究和使用这个库...
Android ADT(ADT-23.0.6.zip)离线包
06-19
1. **Eclipse IDE**: ADT基于Eclipse平台，提供了一个用户友好的图形界面，用于编写、调试和测试Android应用。Eclipse提供了代码编辑器、项目管理工具和资源浏览器等核心功能。 2. **Android SDK**: ADT中集成了...
Android日志分析工具-V3.6.4
07-14
为了解决这些问题，故而开发了此款软件，该软件不仅解决了上述问题，而且还支持对日志文件进行离线分析和导出备份，支持对日志内容的横向过滤和纵向过滤，且可通过ADB工具直连物理设备进行日志的监控和分析，无需...
Android图形系统分析-surfaceFlinger流程
03-10
Android图形系统分析-surfaceFlinger流程.欢迎研究surface 人员下载学习
最新版的android-support-v4.jar
11-03
最新版的`android-support-v4.jar`是1.38MB左右，包含了丰富的类库，使得开发者在开发过程中能享受到更便捷、更稳定的支持。 **向后兼容性** Android设备生态系统多样，系统版本分布广泛，使得开发者面临向后兼容...
android-19最新源码包
01-16
Android 19，也被称为KitKat，是Google在2013年发布的Android操作系统的一个重要版本。这个版本的源码包对于开发者来说是一份宝贵的资源，因为它揭示了系统的内部工作原理，提供了对底层代码的完全访问，使得开发者...
android-sdk-4.2.2 android-sdk-4.2.2-platforms
03-19
标题中的"android-sdk-4.2.2 android-sdk-4.2.2-platforms"指的是Android SDK的一个特定版本，即Android 4.2.2（API级别17），该版本的SDK平台组件。这个版本是Android操作系统的 Jelly Bean 版本的一部分，发布于...
Android-UI刷新
10-27
Android提供了Invalidate方法实现界面刷新，但是Invalidate不能直接在线程中调用，因为他是违背了单线程模型：Android UI操作并不是线程安全的，并且这些操作必须在UI线程中调用。 Android程序中可以使用的界面刷新...
[置顶] Android L SurfaceFlinger dump信息全解(1)
xiayu98020214的专栏
07-27 5303
http://demo.netfoucs.com/lee_3do/article/details/43016299 [置顶] Android L SurfaceFlinger dump信息全解(1) 分类： Android Graphic |2015-01-22 11:22 |2178人阅读 SurfaceFlinger的dump信息详解 对于很多An
HardwareRenderer EGL error: EGL_BAD_SURFACE
OldApple_MrZ的博客
11-13 2262
现象:在打开Activity的时候出现EGL error: EGL_BAD_SURFACE , 设备界面黑屏 ,点击屏幕正常显示 错误日志 2 16:38:11.831 E/IMGSRV ( 2623): :0: gralloc_module_createfence: Failed to merge mapper sync fds 11-12 16:38:11.831 E/IMGSRV (...
Android createWindowSurface failed EGL_BAD_ALLOC 引起Crash的解决方案
cruelder的博客
10-26 5696
这是报错日志：java.lang.RuntimeException: createWindowSurface failed EGL_BAD_ALLOC at android.view.HardwareRenderer$GlRenderer.createSurface(HardwareRenderer.java:1406) at android.view.HardwareRenderer$GlR...
Android通话流程解析：RIL-Java到DriverCall
"通话流程详解，涉及Android系统的RIL-Java、Call、Phone、Connection、DriverCall和CallTracker等核心组件。" 在Android系统中，实现通话功能涉及到一系列复杂的流程和组件交互。以下是对这些关键组件的详细说明：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值