5. 图形缓冲区的释放过程
        前面提到，用户空间的应用程序用到的图形缓冲区是由Gralloc模块中的函数gralloc_free来释放的，这个函数实现在文件hardware/libhardware/modules/gralloc/gralloc.cpp中，如下所示：
  1. static int gralloc_free(alloc_device_t* dev,  
  2.         buffer_handle_t handle)  
  3. {  
  4.     if (private_handle_t::validate(handle) < 0)  
  5.         return -EINVAL;  
  6.   
  7.     private_handle_t const* hnd = reinterpret_cast<private_handle_t const*>(handle);  
  8.     if (hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER) {  
  9.         // free this buffer  
  10.         private_module_t* m = reinterpret_cast<private_module_t*>(  
  11.                 dev->common.module);  
  12.         const size_t bufferSize = m->finfo.line_length * m->info.yres;  
  13.         int index = (hnd->base - m->framebuffer->base) / bufferSize;  
  14.         m->bufferMask &= ~(1<<index);  
  15.     } else {  
  16.         gralloc_module_t* module = reinterpret_cast<gralloc_module_t*>(  
  17.                 dev->common.module);  
  18.         terminateBuffer(module, const_cast<private_handle_t*>(hnd));  
  19.     }  
  20.   
  21.     close(hnd->fd);  
  22.     delete hnd;  
  23.     return 0;  
  24. }  

        要释放的图形缓冲区使用参数handle来描述。前面提到，从Gralloc模块中分配的图形缓冲区是使用private_handle_t结构体来描述的，因此，这里的参数handle应该指向一个private_handle_t结构体，这是通过调用private_handle_t类的静态成员函数validate来验证的。private_handle_t类的静态成员函数validate的实现可以参考前面第1部分的内容。
        要释放的图形缓冲区有可能是在系统帧缓冲区分配的，也有可能是在内存中分配的，这可以通过检查它的标志值flags的PRIV_FLAGS_FRAMEBUFFER位是否等于1来确认。
        如果要释放的图形缓冲区是在系统帧缓冲区中分配的，那么首先要知道这个图形缓冲区是系统帧缓冲区的第index个位置，接着再将变量m所描述的一个private_module_t结构体的成员变量bufferMask的第index位重置为0即可。我们只需要将要释放的图形缓冲区的开始地址减去系统帧缓冲区的基地址，再除以一个图形缓冲区的大小，就可以知道要释放的图形缓冲区是系统帧缓冲区的第几个位置。这个过程刚好是在系统帧缓冲区中分配图形缓冲区的逆操作。
        如果要释放的图形缓冲区是内存中分配的，那么只需要调用另外一个函数terminateBuffer来解除要释放的图形缓冲区在当前进程的地址空间中的映射。
        最后，这个函数还会将用来描述要释放的图形缓冲区的private_handle_t结构体所占用的内存释放掉，并且将要要释放的图形缓冲区所在的系统帧缓冲区或者匿名共享内存的文件描述符关闭掉。
       函数terminateBuffer实现在文件hardware/libhardware/modules/gralloc/mapper.cpp中，如下所示：
  1. int terminateBuffer(gralloc_module_t const* module,  
  2.         private_handle_t* hnd)  
  3. {  
  4.     if (hnd->base) {  
  5.         // this buffer was mapped, unmap it now  
  6.         gralloc_unmap(module, hnd);  
  7.     }  
  8.   
  9.     return 0;  
  10. }  
       它通过调用另外一个函数gralloc_unmap来解除参数hnd所描述的一个图形缓冲区在当前进程的地址空间中的映射。后面在分析图形缓冲区的注销过程时，我们再详细分析函数gralloc_unmap的实现。
       至此，图形缓冲区的释放过程就分析完成了，接下来我们继续分析图形缓冲区的注册过程。
       6. 图形缓冲区的注册过程
       前面提到，在Android系统中，所有的图形缓冲区都是由SurfaceFlinger服务分配的，而当一个图形缓冲区被分配的时候，它会同时被映射到请求分配的进程的地址空间去，即分配的过程同时也包含了注册的过程。但是对用户空间的其它的应用程序来说，它们所需要的图形缓冲区是在由SurfaceFlinger服务分配的，因此，当它们得到SurfaceFlinger服务分配的图形缓冲区之后，还需要将这块图形缓冲区映射到自己的地址空间来，以便可以使用这块图形缓冲区。这个映射的过程即为我们接下来要分析的图形缓冲区注册过程。
       前面还提到，注册图形缓冲区的操作是由Gralloc模块中的函数gralloc_register_buffer来实现的，这个函数实现在文件hardware/libhardware/modules/gralloc/mapper.cpp中，如下所示：
  1. int gralloc_register_buffer(gralloc_module_t const* module,  
  2.         buffer_handle_t handle)  
  3. {  
  4.     if (private_handle_t::validate(handle) < 0)  
  5.         return -EINVAL;  
  6.   
  7.     // if this handle was created in this process, then we keep it as is.  
  8.     int err = 0;  
  9.     private_handle_t* hnd = (private_handle_t*)handle;  
  10.     if (hnd->pid != getpid()) {  
  11.         void *vaddr;  
  12.         err = gralloc_map(module, handle, &vaddr);  
  13.     }  
  14.     return err;  
  15. }  
       这个函数首先验证参数handle指向的一块图形缓冲区的确是由Gralloc模块分配的，方法是调用private_handle_t类的静态成员函数validate来验证，即如果参数handle指向的是一个private_handle_t结构体，那么它所指向的一块图形缓冲区就是由Gralloc模块分配的。
       通过了上面的检查之后，函数gralloc_register_buffer还需要检查当前进程是否就是请求Gralloc模块分配图形缓冲区hnd的进程。如果是的话，那么当前进程在请求Gralloc模块分配图形缓冲区hnd的时候，就已经将图形缓冲区hnd映射进自己的地址空间来了，因此，这时候就不需要重复在当前进程中注册这个图形缓冲区。
       真正执行注册图形缓冲区的操作是由函数gralloc_map来实现的，这个函数也是实现文件hardware/libhardware/modules/gralloc/mapper.cpp中，如下所示：
  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,  
  9.                 PROT_READ|PROT_WRITE, MAP_SHARED, hnd->fd, 0);  
  10.         if (mappedAddress == MAP_FAILED) {  
  11.             LOGE("Could not mmap %s", strerror(errno));  
  12.             return -errno;  
  13.         }  
  14.         hnd->base = intptr_t(mappedAddress) + hnd->offset;  
  15.         //LOGD("gralloc_map() succeeded fd=%d, off=%d, size=%d, vaddr=%p",  
  16.         //        hnd->fd, hnd->offset, hnd->size, mappedAddress);  
  17.     }  
  18.     *vaddr = (void*)hnd->base;  
  19.     return 0;  
  20. }  
       由于在系统帧缓冲区中分配的图形缓冲区只在SurfaceFlinger服务中使用，而SurfaceFlinger服务在初始化系统帧缓冲区的时候，已经将系统帧缓冲区映射到自己所在的进程中来了，因此，函数gralloc_map如果发现要注册的图形缓冲区是在系统帧缓冲区分配的时候，那么就不需要再执行映射图形缓冲区的操作了。
       如果要注册的图形缓冲区是在内存中分配的，即它的标志值flags的PRIV_FLAGS_FRAMEBUFFER位等于1，那么接下来就需要将它映射到当前进程的地址空间来了。由于要注册的图形缓冲区是在文件描述符hnd->fd所描述的一块匿名共享内存中分配的，因此，我们只需要将文件描述符hnd->fd所描述的一块匿名共享内存映射到当前进程的地址空间来，就可以将参数hnd所描述的一个图形缓冲区映射到当前进程的地址空间来。
       由于映射文件描述符hnd->fd得到的是一整块匿名共享内存在当前进程地址空间的基地址，而要注册的图形缓冲区可能只占据这块匿名共享内存的某一小部分，因此，我们还需要将要注册的图形缓冲区的在被映射的匿名共享内存中的偏移量hnd->offset加上被映射的匿名共享内存的基地址hnd->base，才可以得到要注册的图形缓冲区在当前进程中的访问地址，这个地址最终又被写入到hnd->base中去。
       注册图形缓冲区的过程就是这么简单，接下来我们再分析图形缓冲区的注销过程。

转载于:https://blog.51cto.com/shyluo/967092

Android帧缓冲区（Frame Buffer）硬件抽象层（HAL）模块Gralloc的实现原理分析（9）...相关推荐

  1. Android帧缓冲区（Frame Buffer）硬件抽象层（HAL）模块Gralloc的实现原理分析

    前面在介绍Android系统的开机画面时提到,Android设备的显示屏被抽象为一个帧缓冲区,而Android系统中的SurfaceFlinger服务就是通过向这个帧缓冲区写入内容来绘制应用程序的用户 ...

  2. Android帧缓冲区（Frame Buffer）硬件抽象层（HAL）模块Gralloc的实现原理分析（10）...

    7. 图形缓冲区的注销过程        图形缓冲区使用完成之后,就需要从当前进程中注销.前面提到,注销图形缓冲区是由Gralloc模块中的函数gralloc_unregister_buffer来实现 ...

  3. Android帧缓冲区（Frame Buffer）硬件抽象层（HAL）模块Gralloc的实现原理分析（8）...

       4. 分配图形缓冲区         前面提到,用户空间的应用程序用到的图形缓冲区是由Gralloc模块中的函数gralloc_alloc来分配的,这个函数实现在文件hardware/libha ...

  4. Android帧缓冲区（Frame Buffer）硬件抽象层（HAL）模块Gralloc的实现原理分析（2）...

    函数load也是实现在文件hardware/libhardware/hardware.c文件中,如下所示: static int load(const char *id, const char *pa ...

  5. Android帧缓冲区（Frame Buffer）硬件抽象层（HAL）模块Gralloc的实现原理分析（5）...

        3. fb设备的打开过程         在Gralloc模块中,fb设备的ID值定义为GRALLOC_HARDWARE_FB0.GRALLOC_HARDWARE_FB0是一个宏,定义在文件h ...

  6. Android帧缓冲区（Frame Buffer）硬件抽象层（HAL）模块Gralloc的实现原理分析（4）...

            成员变量fd指向一个文件描述符,这个文件描述符要么指向帧缓冲区设备,要么指向一块匿名共享内存,取决于它的宿主结构体private_handle_t描述的一个图形缓冲区是在帧缓冲区分配的 ...

  7. Android帧布局(Frame Layout)

    Android帧布局(Frame Layout) FrameLayout是最简单的一个布局管理器.FrameLayout为每个加入其中的组件创建一个空白区域(一帧),这些组件根据layout_grav ...

  8. 一篇读懂：Android手机如何通过USB接口与外设通信（附原理分析及方案选型）

    更多技术干货,欢迎扫码关注博主微信公众号:HowieXue,共同探讨软件知识经验,关注就有海量学习资料免费领哦: 目录 0背景 1.手机USB接口通信特点 1.1 使用方便 1.2 通用性强 1.3 ...

  9. Android系统Surface机制的SurfaceFlinger服务对帧缓冲区（Frame Buffer）的管理分析

    在前文中,我们分析了SurfaceFlinger服务的启动过程.SurfaceFlinger服务在启动的过程中,会对系统的硬件帧缓冲区进行初始化.由于系统的硬件帧缓冲区一般只有一个,并且不是谁都可以随 ...

最新文章

  1. 维度爆炸？Python实现数据压缩如此简单
  2. python3下载安装配置-Linux 安装python3.7.3
  3. KubeOperator总体介绍（K8S集群部署管理工具）
  4. [js]jquery里的jsonp实现ajax异源请求
  5. 巧用Java8中的Stream，让集合操作6到飞起！！！
  6. 24.QTreeWidget的用法
  7. 2020-03-25 赵子清汇编语言教程
  8. 动态创建Sql Server数据库相关（全）
  9. c#制作飘动动画窗体
  10. c++通过pybind11制作模型python接口，生成python调用包
  11. Docker的镜像管理及配置加速器
  12. android恢复短信中心号码,短信中心号码怎么查 安卓手机查看短信中心号码方法...
  13. CubieBoard2串口
  14. C语言中符号表示什么意思？
  15. kudu作为mysql从机_kudu 知识点学习（一）
  16. 父向子通信（propos基本用法/驼峰命名问题）
  17. matlab lm计算方式,lm算法(lm算法原理介绍)
  18. Uniapp自定义相机界面
  19. 真阳率（true positive rate）、假阳率（false positive rate），AUC，ROC
  20. U.K. Considers Giving RBS Bailout Leeway

热门文章

  1. 基本线程同步（五）使用Lock同步代码块
  2. [转载] 山楂树之恋——01-03
  3. 河南省某炮旅的RAID5恢复
  4. SpringCloud Consul功能介绍及其Raft算法原理
  5. ForkJoinPool 偷任务
  6. Jar包冲突解决方法 Unknown lifecycle phase mvn Eclipse中执行maven命令
  7. Nginx [emerg]: bind() to 0.0.0.0:80 failed (98: Address already in use)
  8. 【MyBatis框架】mapper配置文件-foreach标签
  9. centos8搭建glusterfs服务
  10. 实战：Docker容器虚拟化技术（使用DockerFile构建镜像并搭建 swarm+compose集群）5