BufferQueue学习

最新推荐文章于 2024-05-26 17:35:03 发布
最新推荐文章于 2024-05-26 17:35:03 发布
阅读量925 收藏 3
点赞数
分类专栏： Android显示系统 Android 文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aaajj/article/details/113082092
版权

 

在

https://blog.csdn.net/aaajj/article/details/93653074

https://blog.csdn.net/aaajj/article/details/102537628

里面讨论了从SurfaceFlinger中获取layer图像的一个试验

 

通过获取GraphicBuffer来进行处理的，在实际使用中，GraphicBuffer的管理和获取都是通过BufferQueue来进行的，

 

 

这篇博客写的很好，关于BufferQueue的测试试验，

最简单的BufferQueue测试程序（三）

 

https://blog.csdn.net/hexiaolong2009/article/details/99093375

 

 

通过查看资料，大概可以知道，

 

    sp<IGraphicBufferProducer> producer;

    sp<IGraphicBufferConsumer> consumer;

BufferQueue::createBufferQueue(&producer, &consumer);

 

 

这里我们从进程的角度去查看，BufferQueue在一个进程中生成了，一般是Surfaceflinger，

然后，BufferQueue对象有相关联的2个对象，producer和consumer来分布对应生产者和消费者，producer和BufferQueue是在同一个进程中的，这样就可以进行资源的获取，

但是，producer又作为一个binder服务端对象，这样客户端就可以通过proxy代理对象来和producer来进行通信，进而使客户端进程可以获取到资源。

 

这里再看看画图的例子，

Surface程序

 

修改自https://blog.csdn.net/tung214/article/details/36628897

Android用C++创建surface显示RGB数据

 

很多api变化了，在Android8.1上报错。进行了修改

 

 

 

 

#define LOG_TAG "bindertest"

 

#include <stdio.h>

#include <binder/IInterface.h>

#include <binder/Parcel.h>

#include <binder/IBinder.h>

#include <binder/Binder.h>

#include <binder/ProcessState.h>

#include <binder/IPCThreadState.h>

#include <binder/IServiceManager.h>

 

#include <iostream>

#include <iomanip>

 

#include <unistd.h>

 

//for ALOGD

#include <log/log.h>

 

#include <cutils/memory.h>

 

//test socketpair

#include <sys/types.h>

#include <error.h>

#include <errno.h>

 

#include <gui/Surface.h>

#include <gui/SurfaceComposerClient.h>

#include <android/native_window.h>

 

 

using namespace android;

using namespace std;

//

 

int main(int argc, char** argv)

{

       //the color is ABGR

       int color = 0xFF0000FF;

       if (argc == 2 && argv[1][0] == '1') color = 0xFFFF0000;

       if (argc == 2 && argv[1][0] == '2') color = 0xFF000000;

       if (argc == 2 && argv[1][0] == '3') color = 0xFF00FF00;

       if (argc == 2 && argv[1][0] == '4') color = 0x00FF00FF;

       if (argc == 2 && argv[1][0] == 'b') color = 0x00000000;

       if (argc == 2 && argv[1][0] == 'a') color = 0x00FF00FF;

             

    // set up the thread-pool

    sp<ProcessState> proc(ProcessState::self());

    ProcessState::self()->startThreadPool();

 

    // create a client to surfaceflinger

    sp<SurfaceComposerClient> client = new SurfaceComposerClient();

   

    sp<SurfaceControl> surfaceControl = client->createSurface(String8("testDraw"),

            160, 240, PIXEL_FORMAT_RGBA_8888, 0);

 

    sp<Surface> surface = surfaceControl->getSurface();

 

    SurfaceComposerClient::openGlobalTransaction();

    surfaceControl->setLayer(100000);

    SurfaceComposerClient::closeGlobalTransaction();

 

    ANativeWindow_Buffer outBuffer;

    surface->lock(&outBuffer, NULL);

    ssize_t bpr = outBuffer.stride * bytesPerPixel(outBuffer.format);

    android_memset32((uint32_t*)outBuffer.bits, color, bpr*outBuffer.height);

    surface->unlockAndPost();

 

              cout << "outBuffer.stride = " << outBuffer.stride << ", bytesPerPixel(outBuffer.format) = "

               << bytesPerPixel(outBuffer.format) << ", outBuffer.height = " << outBuffer.height << endl;

/*

    surface->lock(&outBuffer, NULL);

    android_memset16((uint16_t*)outBuffer.bits, 0x07E0, bpr*outBuffer.height);

    surface->unlockAndPost();

 

    SurfaceComposerClient::openGlobalTransaction();

    surfaceControl->setSize(320, 240);

    SurfaceComposerClient::closeGlobalTransaction();

 */  

    IPCThreadState::self()->joinThreadPool();

   

    return 0;

}

 

Android.mk

LOCAL_PATH := $(call my-dir)

 

#for service

 

include $(CLEAR_VARS)

 

 

LOCAL_SRC_FILES:= \

        service.cpp

       

 

LOCAL_SHARED_LIBRARIES := \

        libbase \

        libutils \

        liblog \

        libbinder \

        libcutils libskia libui libgui

 

 

LOCAL_CFLAGS += -Wall -Werror -Wunused -Wunreachable-code       

 

 

LOCAL_MODULE:= testDraw

 

include $(BUILD_EXECUTABLE)

 

 

执行程序，在手机上显示160*240的surface

 

 

 

 

看上去通过这么简单的几个操作就获取到了GraphicBuffer

    sp<SurfaceComposerClient> client = new SurfaceComposerClient();

   

    sp<SurfaceControl> surfaceControl = client->createSurface(String8("testDraw"),

            160, 240, PIXEL_FORMAT_RGBA_8888, 0);

 

    sp<Surface> surface = surfaceControl->getSurface();

 

    ANativeWindow_Buffer outBuffer;

    surface->lock(&outBuffer, NULL);

    ssize_t bpr = outBuffer.stride * bytesPerPixel(outBuffer.format);

    android_memset32((uint32_t*)outBuffer.bits, color, bpr*outBuffer.height);

 

 

看上去没有BufferQueue，producer什么事情一样，

 

 

在client->createSurface的时候，已经创建了producer对象

//frameworks/native/libs/gui/SurfaceComposerClient.cpp

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;

}

 

里面的mClient->createSurface调用到

//frameworks/native/services/surfaceflinger/Client.cpp

status_t Client::createSurface(

        const String8& name,

        uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,

        sp<IBinder>* handle,

        sp<IGraphicBufferProducer>* gbp)

{

    /*

     * createSurface must be called from the GL thread so that it can

     * have access to the GL context.

     */

 

    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;

    public:

        MessageCreateLayer(SurfaceFlinger* flinger,

                const String8& name, Client* client,

                uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,

                sp<IBinder>* handle,

                sp<IGraphicBufferProducer>* gbp)

            : flinger(flinger), client(client),

              handle(handle), gbp(gbp), result(NO_ERROR),

              name(name), w(w), h(h), format(format), flags(flags) {

        }

        status_t getResult() const { return result; }

        virtual bool handler() {

            result = flinger->createLayer(name, client, w, h, format, flags,

                    handle, gbp);

            return true;

        }

    };

 

    sp<MessageBase> msg = new MessageCreateLayer(mFlinger.get(),

            name, this, w, h, format, flags, handle, gbp);

    mFlinger->postMessageSync(msg);

    return static_cast<MessageCreateLayer*>( msg.get() )->getResult();

}

 

然后调用到SurfaceFlinger里面去了

 

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)

{

    ......

    *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();

    }

 

    return err;

}

在SurfaceFliger里创建了Layer对象，并且和gbp即producer关联起来了，

 

注意看，Layer创建的时候，创建了BufferQueue对象，

 

//frameworks/native/services/surfaceflinger/Layer.cpp

void Layer::onFirstRef() {

    // Creates a custom BufferQueue for SurfaceFlingerConsumer to use

    sp<IGraphicBufferProducer> producer;

    sp<IGraphicBufferConsumer> consumer;

    BufferQueue::createBufferQueue(&producer, &consumer);

    mProducer = new MonitoredProducer(producer, mFlinger);

    mSurfaceFlingerConsumer = new SurfaceFlingerConsumer(consumer, mTextureName);

    ......

}

 

通过这样一系列操作，画图进程其实里面已经有了produce对象，

再看看这个最基本的绘图程序，

    sp<SurfaceComposerClient> client = new SurfaceComposerClient();

   

    sp<SurfaceControl> surfaceControl = client->createSurface(String8("testDraw"),

            160, 240, PIXEL_FORMAT_RGBA_8888, 0);

 

    sp<Surface> surface = surfaceControl->getSurface();

 

    ANativeWindow_Buffer outBuffer;

    surface->lock(&outBuffer, NULL);

    ssize_t bpr = outBuffer.stride * bytesPerPixel(outBuffer.format);

    android_memset32((uint32_t*)outBuffer.bits, color, bpr*outBuffer.height);

    surface->unlockAndPost();

 

createSurface操作后，在画图进程中已经有了producer对象，

按照BufferQueue的资料介绍，需要通过dequeueBuffer操作来获取GraphicBuffer，现在好像没有看到dequeueBuffer，

我们来看看lock的实现，

//frameworks/native/libs/gui/Surface.cpp

status_t Surface::lock(

        ANativeWindow_Buffer* outBuffer, ARect* inOutDirtyBounds)

{

    ......

    ANativeWindowBuffer* out;

    int fenceFd = -1;

    //拿到一个缓冲区

    status_t err = dequeueBuffer(&out, &fenceFd);

    if (err == NO_ERROR) {

        sp<GraphicBuffer> backBuffer(GraphicBuffer::getSelf(out));

        ......

        void* vaddr;

        status_t res = backBuffer->lockAsync(

                GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,

                newDirtyRegion.bounds(), &vaddr, fenceFd);

        if (res != 0) {

            err = INVALID_OPERATION;

        } else {

            mLockedBuffer = backBuffer;

            outBuffer->width  = backBuffer->width;

            outBuffer->height = backBuffer->height;

            outBuffer->stride = backBuffer->stride;

            outBuffer->format = backBuffer->format;

            outBuffer->bits   = vaddr;

        }

    }

    return err;

}

里面的dequeueBuffer调用到

231int Surface::dequeueBuffer(android_native_buffer_t** buffer, int* fenceFd) {

…



260    int buf = -1;
261    sp<Fence> fence;
262    status_t result = mGraphicBufferProducer->dequeueBuffer(&buf, &fence,
263            reqWidth, reqHeight, reqFormat, reqUsage);
264
265    if (result < 0) {
266        ALOGV("dequeueBuffer: IGraphicBufferProducer::dequeueBuffer"
267                "(%d, %d, %d, %d) failed: %d", reqWidth, reqHeight, reqFormat,
268                reqUsage, result);
269        return result;
270    }
271
272    Mutex::Autolock lock(mMutex);
273
274    sp<GraphicBuffer>& gbuf(mSlots[buf].buffer);
275
276    // this should never happen
277    ALOGE_IF(fence == NULL, "Surface::dequeueBuffer: received null Fence! buf=%d", buf);
278
279    if (result & IGraphicBufferProducer::RELEASE_ALL_BUFFERS) {
280        freeAllBuffers();
281    }
282
283    if ((result & IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION) || gbuf == 0) {
284        result = mGraphicBufferProducer->requestBuffer(buf, &gbuf);
285        if (result != NO_ERROR) {
286            ALOGE("dequeueBuffer: IGraphicBufferProducer::requestBuffer failed: %d", result);
287            mGraphicBufferProducer->cancelBuffer(buf, fence);
288            return result;
289        }
290    }
291
292    if (fence->isValid()) {
293        *fenceFd = fence->dup();
294        if (*fenceFd == -1) {
295            ALOGE("dequeueBuffer: error duping fence: %d", errno);
296            // dup() should never fail; something is badly wrong. Soldier on
297            // and hope for the best; the worst that should happen is some
298            // visible corruption that lasts until the next frame.
299        }
300    } else {
301        *fenceFd = -1;
302    }
303
304    *buffer = gbuf.get();
305
306    if (mSharedBufferMode && mAutoRefresh) {
307        mSharedBufferSlot = buf;
308        mSharedBufferHasBeenQueued = false;
309    } else if (mSharedBufferSlot == buf) {
310        mSharedBufferSlot = BufferItem::INVALID_BUFFER_SLOT;
311        mSharedBufferHasBeenQueued = false;
312    }
313
314    return OK;
315}

 

 

可以看到，调用了producer的dequeueBuffer方法，

 

    sp<SurfaceControl> surfaceControl = client->createSurface(String8("testDraw"),

            160, 240, PIXEL_FORMAT_RGBA_8888, 0);

 

    sp<Surface> surface = surfaceControl->getSurface();

 

    ANativeWindow_Buffer outBuffer;

    surface->lock(&outBuffer, NULL);

 

这几句代码中，真是暗潮汹涌，隐藏了BufferQueue的相关操作细节。

 

 

 

参考资料：

https://www.jianshu.com/p/993e66015c18

Android 绘图机制

 

 

https://blog.csdn.net/tung214/article/details/36628897

Android用C++创建surface显示RGB数据

 

 

 

aaajj
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
androidP Surface到SurfaceFlinger --＞surface -＞ BufferQueue（一）
android
12-28 1746
BufferQueue前言介绍BufferQueue::createBufferQueue 前言 结合前面的一篇文章创建Surface, 我们知道最后会调用到SurfaceFlinger的CreateLayer() 方法，然后会层层调用到 BufferQueue::createBufferQueue()，今天我们就来理理BufferQueue。 介绍 首先我们要知道BufferQueue的大致工作原理，一个surface会和一个Producer及生产者App进行绑定去产生view数据，然后会通过onFram
BufferQueue研究
lonely_fireworks的专栏
03-06 1950
了解BufferQueue,有助于分析应用卡顿问题。
ic基础|时钟篇05：芯片中buffer到底是干嘛的？一文带你了解buffer的作用
最新发布
demayiya的博客
05-26 1768
以上是buffer功能的简要介绍啦，在下篇文章中，我们将之前提到过的时钟门控、时钟分频、时钟切换、osc和pll等电路组合起来，就可以组成一个基础的时钟和复位产生模块（CRG, clock reset generator）中的时钟部分电路，我们将在下篇文章对其进行介绍，那么我们下次再见~往期时钟篇文章：[ic基础|时钟篇：关于时钟切换的二三事(https://mp.weixin.qq.com/s?ic基础|时钟篇02：关于时钟分频器的二三事。
BufferQueueProducer和surface联系
haodada1226的博客
12-04 3910
一、Surface::dequeueBuffer申请图形缓冲区（buffer类型为buffer_handle_t handle） 详情参考1： android graphic(8)—surface申请GraphicBuffer过程_lyf's blog-CSDN博客 详情参考2： Android SurfaceFlinger 学习之路(七)----创建图形缓冲区GraphicBuffer_STN_LCD的专栏-CSDN博客 总结： 1.surface先调用dequeueBuffer向Buf...
BufferQueue/consumer/producer
Embeded system Development
11-22 2983
针对Jelly Bean版本的代码。 SurfaceFlinger是什么，这些介绍大家可以在网络上找找看，这里就直接上代码。 首先我们得了解一种常用的编程做法，生产者/消费者模型，也许都会觉得很简单，但是这里就用到了很多这些基本概念。 BufferQueue 数据都queue到这里面，前提是它是先从BufferQueue取出一个空的数据单元，称为一个buffer，实际为GraphicBu
App的启动过程（7）BufferQueue的申请分配
lin20080410的专栏
06-01 3589
接下来看下BufferQueue的申请分配，就是经典的生产者-消费者模型。 1）BufferQueueCore 可以认为BufferQueueCore是一个服务中心，生产者、消费者都要通过它来管理buffer。里面有一个重要的成员数组：BufferQueueDefs::SlotsType mSlots;这个BufferSlot中有一个成员变量：spmGraphicBuffer;记录这个slot
Iris-BufferQueue:用于在本地主机上缓冲数据的快速、进程内、持久化队列
06-21
Iris-BufferQueue 是作为 Java 库实现的消息队列。 它主要用于在异步处理数据之前缓冲本地主机上的数据。 Iris-BufferQueue 具有以下特点： 它是一个进程内队列，尽管写入队列并从中消费可以发生在两个不同的进程...
android系统framework层代码分析PPT学习教案.pptx
10-06
SurfaceFlinger不断接收并处理来自各个应用的BufferQueue，进行合成操作，并将结果呈现到显示屏。 4. **Transaction分析** Transaction是SurfaceFlinger更新显示状态的方式，包括改变Surface的位置、大小等属性。...
DoubleBufferQueue:使用 lambda 实现双缓冲队列和范围保护
06-17
双缓冲队列使用 lambda 实现双缓冲队列和范围保护
Abandoned.-开源
05-26
这个项目已经十多年没有更新或维护过了。 您可能不应该使用它。
surfaceFlinger代码分析
03-10
SurfaceFlinger 负责管理 BufferQueue，BufferQueue 是一个生产者/消费者模型，生产者将 Buffer push 到队列中，而消费者从队列中取出 Buffer。 在 Android Jelly Bean 版本中，SurfaceFlinger 的代码实现中使用了...
3分钟带你搞懂栈和队列（Python实现）——不懂你锤我
12-21
栈和队列是两种基础但极其重要的数据结构，在计算机科学中有着广泛的应用。它们都是用来组织和管理数据的容器，但各自遵循不同的访问规则。...学习并熟练掌握栈和队列的使用，对于提升编程能力至关重要。
Android-OpenSLES-Demo1.rar_Android OpenSL ES_android_android ope
07-15
(*playerObject)->GetInterface(playerObject, SL_IID_BUFFERQUEUE, &bufferQueue); (*bufferQueue)->RegisterCallback(bufferQueue, bufferQueueCallback, NULL); (*player)->SetPlayState(player, SL_PLAYSTATE_...
opensl-jni:使用OpenSL的Android示例音频播放器
05-22
4. **添加缓冲到BufferQueue**: 将解码后的PCM数据送入BufferQueue，OpenSL ES会自动处理播放。 5. **控制播放**: 通过AudioPlayer接口进行播放、暂停、停止等操作。 6. **错误处理和资源释放**: 当播放结束或出现...
Android OpenSLES
06-02
**Android OpenSLES** ...测试代码还会涉及到错误处理和性能调整的示例，这些都是理解和学习OpenSLES的关键步骤。通过深入研究这个测试项目，开发者可以更好地掌握OpenSLES在实际应用中的使用方法，提升音频处理能力。
Android屏幕刷新机制11
08-08
2. BufferQueue：BufferQueue 是 Android 系统中的一种缓存机制，它负责存储屏幕上的图像数据。 3. GraphicBuffer：GraphicBuffer 是 Android 系统中的一种图形缓存机制，它负责存储图形数据。 屏幕刷新机制的类型 ...
BufferQueue
qwaszx523的博客
01-09 775
 1.BufferQueue内部原理 BufferQueue是IGraphicBufferProducer服务器端的实现；所以BufferQueue会重载IGraphicBufferProducer接口中的各个虚函数queueBuffer,requesBuffer,dequeueBuffer等，该类内部还有一个mSlots[NUM_BUFFER_SLOTS]; 1.1 mSl
BufferQueue详解 原理
热门推荐
王瑞
12-28 1万+
BufferQueue详解一、BufferQueue 简介二、生产者消费者模型1.生产者消费者模型基本原理2.生产者消费者模型的组成三、BufferQueue基本原理1.BufferQueue的生产消费框架2.BufferQueueCore概述3.BufferSlot和BufferItem详解4.BufferCount详解四、BufferQueue中的生产者和消费者详解1.BufferQueue中...
android获取图片的rgb,使用ImageReader读取RGB图像
weixin_39848970的博客
05-29 3150
我正在尝试使用ImageReader从相机中获取RGB图像。 我在运行开发者预览版的Nexus 5上使用Android 5.0“L”的Camera2 API。我已经为RGB图像配置了SurfaceView ，它工作正常，我知道相机硬件会生成RGB数据(因为Android上的所有色调映射和颜色增益设置都指定为在RGB通道上运行)。我可以通过以下方式创建ImageReader从ImageReader获...
BufferQueue原理
03-25
BufferQueue是Android系统中用来管理图像、视频等媒体资源的队列。它的原理是通过Producer、Consumer两端的线程交互来实现资源的生产和消费。Producer端负责生产资源并放入队列中，而Consumer端则负责从队列中取出...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值