Android图形缓冲区映射过程源码分析

来源:互联网 发布:南大碎尸案推理 知乎 编辑:程序博客网 时间:2024/05/29 11:05

原文:http://blog.csdn.net/yangwen123/article/details/12234931?utm_source=tuicool

Android图形缓冲区分配过程源码分析中介绍了图形buffer的分配过程,图形buffer可以从系统帧缓冲区分配也可以从内存中分配,分配一个图形buffer后还需要将该图形缓冲区映射到分配该buffer的进程地址空间来,在Android系统中,图形buffer的管理由SurfaceFlinger服务来负责,在Android SurfaceFlinger服务启动过程源码分析中我们了解到SurfaceFlinger可以以服务进程的方式启动也可以以服务线程的方式在SystemServer进程中启动,如果是以服务进程的方式启动,那么创建的图形缓冲区就将映射到SurfaceFlinger进程地址空间;如果是以服务线程的方式在SystemServer中启动,那么创建的图形缓冲区将映射到SystemServer进程地址空间。在系统帧缓冲区中分配的图形缓冲区是在SurfaceFlinger服务中使用,而在内存中分配的图形缓冲区既可以在SurfaceFlinger服务中使用,也可以在其它的应用程序中使用。当其它的应用程序需要使用图形缓冲区的时候,它们就会请求SurfaceFlinger服务为它们分配并将SurfaceFlinger服务返回来的图形缓冲区映射到应用程序进程地址空间。图形缓冲区的分配过程在Android图形缓冲区分配过程源码分析中已经分析过了,在从内存中分配buffer时,已经将分配的buffer映射到了SurfaceFlinger服务进程地址空间,如果该buffer是应用程序请求SurfaceFlinger服务为它们分配的,那么还需要将SurfaceFlinger服务返回来的图形缓冲区映射到应用程序进程地址空间,本文介绍图形缓冲区映射到应用程序进程地址空间的过程。


Android提供了GraphicBufferMapper工具类,该类为上层访问Gralloc模块中的gralloc_module_t提供了接口,采用单例模式构造GraphicBufferMapper对象。

[cpp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. GraphicBufferMapper::GraphicBufferMapper(): mAllocMod(0)  
  2. {  
  3.     hw_module_t const* module;  
  4.     //根据模块ID得到模块描述符的首地址  
  5.     int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module);  
  6.     ALOGE_IF(err, "FATAL: can't find the %s module", GRALLOC_HARDWARE_MODULE_ID);  
  7.     if (err == 0) {  
  8.         //将hw_module_t的指针转换为gralloc_module_t类型指针  
  9.         mAllocMod = (gralloc_module_t const *)module;  
  10.     }  
  11. }  
硬件抽象层模块的加载过程在Android硬件抽象Hardware库加载过程源码分析中有详细的分析,这里根据模块ID加载Gralloc模块,并得到Gralloc模块的HMI符号首地址,并强制转换为gralloc_module_t类型指针。

GraphicBufferMapper提供了访问Gralloc模块的gralloc_module_t接口,GraphicBuffer就是通过其成员变量mBufferMapper来注册buffer的。

GraphicBuffer::unflatten()     
-->GraphicBufferMapper::registerBuffer()        
-->mAllocMod->registerBuffer()
-->gralloc_register_buffer()


GraphicBuffer::free_handle()      
-->GraphicBufferMapper::unregisterBuffer()
-->mAllocMod->unregisterBuffer()         
-->gralloc_unregister_buffer()


GraphicBuffer::lock()      
-->GraphicBufferMapper::lock()
-->mAllocMod->lock() 
-->gralloc_lock()


GraphicBuffer::unlock()      
-->GraphicBufferMapper::unlock()
-->mAllocMod->unlock() 
-->gralloc_unlock()

registerBuffer和unregisterBuffer分别用来注册和注销一个指定的图形缓冲区,所谓注册图形缓冲区,实际上就是将一块图形缓冲区映射到一个进程的地址空间去,而注销图形缓冲区就是执行相反的操作。lock和unlock分别用来锁定和解锁一个指定的图形缓冲区,在访问一块图形缓冲区的时候,例如,向一块图形缓冲写入内容的时候,需要将该图形缓冲区锁定,用来避免访问冲突。在锁定一块图形缓冲区的时候,可以指定要锁定的图形绘冲区的位置以及大小,这是通过参数l、t、w和h来指定的,其中,参数l和t指定的是要访问的图形缓冲区的左上角位置,而参数w和h指定的是要访问的图形缓冲区的宽度和长度。锁定之后,就可以获得由参数参数l、t、w和h所圈定的一块缓冲区的起始地址,保存在输出参数vaddr中。另一方面,在访问完成一块图形缓冲区之后,需要解除这块图形缓冲区的锁定。

1. 图形缓冲区的注册过程

[cpp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. status_t GraphicBufferMapper::registerBuffer(buffer_handle_t handle)  
  2. {  
  3.     ATRACE_CALL();  
  4.     status_t err;  
  5.     err = mAllocMod->registerBuffer(mAllocMod, handle);  
  6.     return err;  
  7. }  
这里直接通过成员变量mAllocMod来调用gralloc_module_t中的registerBuffer函数来注册图形buffer
[cpp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. int gralloc_register_buffer(gralloc_module_t const* module,buffer_handle_t handle)  
  2. {  
  3.     //校验图形buffer  
  4.     if (private_handle_t::validate(handle) < 0)  
  5.         return -EINVAL;  
  6.     // if this handle was created in this process, then we keep it as is.  
  7.     int err = 0;  
  8.     private_handle_t* hnd = (private_handle_t*)handle;  
  9.     //判断当前进程是否为创建该图形buffer的进程,如果是创建该图形buffer的进程,则不需要在重复映射了,因为在创建过程中已经完成了地址空间的映射过程  
  10.     if (hnd->pid != getpid()) {  
  11.         void *vaddr;  
  12.         err = gralloc_map(module, handle, &vaddr);  
  13.     }  
  14.     return err;  
  15. }  

这里的图形缓冲区的注册过程是针对应用程序进程的,服务端负责创建图形buffer,同时在创建的过程中自动将创建的图形buffer映射到服务进程地址空间,应用程序进程通过Binder进程间通信机制得到服务进程返回来的图形buffer,依然需要映射到应用程序进程,这样应用程序进程才能直接访问该图形buffer。这里通过进程ID号来区分当前进程是否为创建图形buffer的进程。
[cpp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. static int gralloc_map(gralloc_module_t const* module,  
  2.         buffer_handle_t handle,  
  3.         void** vaddr)  
  4. {  
  5.     private_handle_t* hnd = (private_handle_t*)handle;  
  6.     if (!(hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER)) {  
  7.         size_t size = hnd->size;  
  8.         void* mappedAddress = mmap(0, size,PROT_READ|PROT_WRITE, MAP_SHARED, hnd->fd, 0);  
  9.         if (mappedAddress == MAP_FAILED) {  
  10.             ALOGE("Could not mmap %s", strerror(errno));  
  11.             return -errno;  
  12.         }  
  13.         hnd->base = intptr_t(mappedAddress) + hnd->offset;  
  14.     }  
  15.     *vaddr = (void*)hnd->base;  
  16.     return 0;  
  17. }  
这里通过系统调用mmap将服务端创建的图形缓冲区映射到应用程序进程地址空间。

2. 图形缓冲区的注销过程

图形缓冲区的注销过程和注册过程恰恰相反,函数调用过程类型,就是取消地址空间映射。
[cpp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. status_t GraphicBufferMapper::unregisterBuffer(buffer_handle_t handle)  
  2. {  
  3.     ATRACE_CALL();  
  4.     status_t err;  
  5.     err = mAllocMod->unregisterBuffer(mAllocMod, handle);  
  6.     ALOGW_IF(err, "unregisterBuffer(%p) failed %d (%s)",handle, err, strerror(-err));  
  7.     return err;  
  8. }  
直接调用gralloc_module_t中的unregisterBuffer函数来注销图形buffer
[cpp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. int gralloc_unregister_buffer(gralloc_module_t const* module,buffer_handle_t handle)  
  2. {  
  3.     if (private_handle_t::validate(handle) < 0)  
  4.         return -EINVAL;  
  5.     // never unmap buffers that were created in this process  
  6.     private_handle_t* hnd = (private_handle_t*)handle;  
  7.     if (hnd->pid != getpid()) {  
  8.         if (hnd->base) {  
  9.             gralloc_unmap(module, handle);  
  10.         }  
  11.     }  
  12.     return 0;  
  13. }  
通过进程ID来判断是否需要取消映射
[cpp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. static int gralloc_unmap(gralloc_module_t const* module,buffer_handle_t handle)  
  2. {  
  3.     private_handle_t* hnd = (private_handle_t*)handle;  
  4.     if (!(hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER)) {  
  5.         void* base = (void*)hnd->base;  
  6.         size_t size = hnd->size;  
  7.         if (munmap(base, size) < 0) {  
  8.             ALOGE("Could not unmap %s", strerror(errno));  
  9.         }  
  10.     }  
  11.     hnd->base = 0;  
  12.     return 0;  
  13. }  
调用munmap系统调用来取消图形buffer映射过程。

3. 图形缓冲区的锁定过程

[cpp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. status_t GraphicBufferMapper::lock(buffer_handle_t handle,   
  2.         int usage, const Rect& bounds, void** vaddr)  
  3. {  
  4.     ATRACE_CALL();  
  5.     status_t err;  
  6.     err = mAllocMod->lock(mAllocMod, handle, usage,  
  7.             bounds.left, bounds.top, bounds.width(), bounds.height(),vaddr);  
  8.     ALOGW_IF(err, "lock(...) failed %d (%s)", err, strerror(-err));  
  9.     return err;  
  10. }  
直接调用gralloc_module_t中的lock函数来锁定该图形buffer
[cpp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. int gralloc_lock(gralloc_module_t const* module,  
  2.         buffer_handle_t handle, int usage,  
  3.         int l, int t, int w, int h,  
  4.         void** vaddr)  
  5. {  
  6.     //根据硬件来具体实现  
  7.     return 0;  
  8. }  

4. 图形缓冲区的解锁过程

[cpp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. status_t GraphicBufferMapper::unlock(buffer_handle_t handle)  
  2. {  
  3.     ATRACE_CALL();  
  4.     status_t err;  
  5.     err = mAllocMod->unlock(mAllocMod, handle);  
  6.     ALOGW_IF(err, "unlock(...) failed %d (%s)", err, strerror(-err));  
  7.     return err;  
  8. }  
直接调用gralloc_module_t中的unlock函数来解锁该图形buffer
[cpp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. int gralloc_unlock(gralloc_module_t const* module, buffer_handle_t handle)  
  2. {  
  3.     if (private_handle_t::validate(handle) < 0)  
  4.         return -EINVAL;  
  5.     //根据硬件来具体实现  
  6.     ...  
  7.     return 0;  


0 0
原创粉丝点击