android graphic(7)—gralloc分配图形缓冲区

时间：2022-06-17 15:12:28

android中，HAL层的gralloc库负责了申请图形缓冲区的所有工作，HAL层之上的Surface、BufferQueue最终都是调用gralloc库去申请图形缓冲区，然后返回给上层一个buffer_handle_t的handle，这个handle的结构大致如下所示，

typedef struct native_handle
{
int version;        /* sizeof(native_handle_t) */
//data[0]中的文件描述符个数
int numFds;         /* number of file-descriptors at &data[0] */
//&data[numFds]中int的个数
int numInts;        /* number of ints at &data[numFds] */
int data[0];        /* numFds + numInts ints */
} native_handle_t;

typedef const native_handle_t* buffer_handle_t;

返回的这个handle中的实际有用数据都在data[0]中，里面有fd和一些int值，都是些什么？先分析下gralloc如何分配图形缓冲区，在分配缓冲区时mmap函数是关键。

mmap

mmap可以将某个设备或者文件映射到应用程序进程的内存空间中，mmap函数返回值为用户空间映射的这段内存，这样访问这段内存就相当于对设备/文件进行读写，而不用再通过read()，write()了，减少了数据拷贝的次数。

void* mmap(void* start,size_t length,int prot,int flags,int fd,off_t offset);

一个使用的例子为，通过mmap将fd所对应的文件或者设备映射到用户进程，返回的用户进程内存起始地址为vaddr，大小为fbSize，

void* vaddr = mmap(0, fbSize, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);

上面data[0]中里面的fd和一些int值最主要的就是mmap中的fd、fbSize、以及返回的起始地址vaddr，而gralloc分配图形缓冲区，又分为framebuffer图形缓冲区和普通图形缓冲区两种。

gralloc分配framebuffer图形缓冲区

gralloc调用gralloc_alloc_framebuffer()分配framebuffer的内存，其核心是对fb设备/dev/graphics/fb*或者/dev/fb*执行mmap()，映射到用户空间，然后去操作。

static int gralloc_alloc_framebuffer(alloc_device_t* dev,
        size_t size, int usage, buffer_handle_t* pHandle)
{
    private_module_t* m = reinterpret_cast<private_module_t*>(
            dev->common.module);
    pthread_mutex_lock(&m->lock);
int err = gralloc_alloc_framebuffer_locked(dev, size, usage, pHandle);
    pthread_mutex_unlock(&m->lock);
return err;
}
static int gralloc_alloc_framebuffer_locked(alloc_device_t* dev,
        size_t size, int usage, buffer_handle_t* pHandle)
{
    private_module_t* m = reinterpret_cast<private_module_t*>(
            dev->common.module);

// allocate the framebuffer
if (m->framebuffer == NULL) {
// initialize the framebuffer, the framebuffer is mapped once
// and forever.
//framebuffer的分配主要就是对fb设备的映射
int err = mapFrameBufferLocked(m);
if (err < 0) {
return err;
        }
    }
    .........
}
int mapFrameBufferLocked(struct private_module_t* module)
{
// already initialized...
if (module->framebuffer) {
return 0;
    }

char const * const device_template[] = {
"/dev/graphics/fb%u",
"/dev/fb%u",
0 };

int fd = -1;
int i=0;
char name[64];
//打开设备文件，返回fd
while ((fd==-1) && device_template[i]) {
        snprintf(name, 64, device_template[i], 0);
        fd = open(name, O_RDWR, 0);
        i++;
    }
    ............
//对fd进行mmap，大小为fbSize
void* vaddr = mmap(0, fbSize, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
if (vaddr == MAP_FAILED) {
        ALOGE("Error mapping the framebuffer (%s)", strerror(errno));
return -errno;
    }
//这个返回的vaddr,就是申请的图形缓冲区，需要保存起来，返回给上层
module->framebuffer->base = intptr_t(vaddr);
    memset(vaddr, 0, fbSize);
 }

gralloc分配普通图形缓冲区

而普通图形缓冲区的分配是调用gralloc_alloc_buffer()，其核心是先在内核中创建一块匿名共享内存，关于匿名共享内存网上有很多资料(匿名共享内存通过tmpfs临时文件、binder传递fd可以将内核中的同一块内存映射到不同进程中，这样也是一种进程间通信的方式，普通图形缓冲区就是通过这种方式在不同进程中进行共享的，例如在BufferQueue所在进程中创建buffer，然后在Surface所在进程中通过映射使用这个buffer)，调用ashmem_create_region()返回对应的fd，然后再对这个fd，size进行映射，给上层进程返回缓冲区的起始地址。

static int gralloc_alloc_buffer(alloc_device_t* dev,
        size_t size, int usage, buffer_handle_t* pHandle)
{
int err = 0;
int fd = -1;

    size = roundUpToPageSize(size);
//① 创建匿名共享内存
    fd = ashmem_create_region("gralloc-buffer", size);
if (fd < 0) {
        ALOGE("couldn't create ashmem (%s)", strerror(-errno));
        err = -errno;
    }

if (err == 0) {
        private_handle_t* hnd = new private_handle_t(fd, size, 0);
        gralloc_module_t* module = reinterpret_cast<gralloc_module_t*>(
                dev->common.module);
//② 执行mmap对内存进行mmap
        err = mapBuffer(module, hnd);
if (err == 0) {
            *pHandle = hnd;
        }
    }

    ALOGE_IF(err, "gralloc failed err=%s", strerror(-err));

return err;
}
标签：

相关文章