Android 中 lcd 是一个帧缓冲设备，驱动程序通过处理器的 lcd 控制器将物理内存的一段区域设置为显存，如果向这段内存区域写入数据就会马上在 lcd 上显示出来。Android 在 HAL 中提供了gralloc 模块，封装了用户层对帧缓冲设备的所有操作接口，并通过 SurfaceFlinger 服务向应用提供显示支持。在启动过程中系统会加载 gralloc 模块，然后打开帧缓冲设备，获取设备的各种参数并完成 gralloc 模块的初始化。当应用程序需要把内容显示到 lcd 上时，需要通过 gralloc 模块申请一块图形缓冲区，然后将这块图形缓冲区映射到自己的地址空间并写入内容即可。当应用程序不再需要这块图形缓冲区时需要通过 gralloc 模块释放掉，然后解除对缓冲区的映射。

1、基础数据结构

gralloc 模块通过struct private_module_t 来描述，该结构定义如下：

[cpp] view plain copy

1. structprivate_module_t{
2. gralloc_module_tbase;
4. private_handle_t*framebuffer;/*指向图形缓冲区的句柄*/
5. uint32_tflags;/*用来标志系统帧缓冲区是否支持双缓冲*/
6. uint32_tnumBuffers;/*表示系统帧缓冲的个数*/
7. uint32_tbufferMask;/*记录系统帧缓冲的使用情况*/
8. pthread_mutex_tlock;/*保护结构体private_module_t的并行访问*/
9. buffer_handle_tcurrentBuffer;/*描述当前正在被渲染的图形缓冲区*/
10. intpmem_master;/*pmem设备节点的描述符*/
11. void*pmem_master_base;/*pmem的起始虚拟地址*/
13. structfb_var_screeninfoinfo;/*lcd的可变参数*/
14. structfb_fix_screeninfofinfo;/*lcd的固定参数*/
15. floatxdpi;/*x方向上每英寸的像素数量*/
16. floatydpi;/*y方向上每英寸的像素数量*/
17. floatfps;/*lcd的刷新率*/
19. intorientation;/*显示方向*/
21. enum{
22. PRIV_USAGE_LOCKED_FOR_POST=0x80000000/*flagtoindicatewe'llpostthisbuffer*/
23. };
24. };

该结构的成员记录了 gralloc 模块的各种参数，主要为模块自己使用，应用程序操作的 图形缓冲区的数据结构是 struct private_handle_t，定义如下：
[cpp] view plain copy

1. #ifdef__cplusplus
2. structprivate_handle_t:publicnative_handle{
3. #else
4. structprivate_handle_t{
5. structnative_handlenativeHandle;/*用来描述一个本地句柄值*/
6. #endif
8. enum{
9. PRIV_FLAGS_FRAMEBUFFER=0x00000001,
10. PRIV_FLAGS_USES_PMEM=0x00000002,
11. PRIV_FLAGS_USES_MMEM=0x00000004,
12. PRIV_FLAGS_NEEDS_FLUSH=0x00000008,
13. };
15. enum{
16. LOCK_STATE_WRITE=1<<31,
17. LOCK_STATE_MAPPED=1<<30,
18. LOCK_STATE_READ_MASK=0x3FFFFFFF
19. };
21. /*指向一个文件描述符，这个文件描述符要么指向帧缓冲区设备，要么指向一块匿名共享内存
22. *取决于private_handle_t描述的图形缓冲区是在帧缓冲区分配的，还是在内存中分配的*/
23. intfd;
24. /*指向一个魔数，它的值由静态成员变量sMagic来指定，用来标识一个private_handle_t结构体*/
25. intmagic;
26. /*用来描述一个图形缓冲区的标志，它的值要么等于0，要么等于PRIV_FLAGS_FRAMEBUFFER
27. *当一个图形缓冲区的标志值等于PRIV_FLAGS_FRAMEBUFFER的时候，就表示它是在帧缓冲区中分配的*/
28. intflags;
29. intsize;/*描述一个图形缓冲区的大小*/
30. intoffset;/*描述一个图形缓冲区的偏移地址*/
32. intphys;/*图形缓冲区或帧缓冲的起始物理地址*/
33. intbase;/*图形缓冲区或帧缓冲的起始虚拟地址*/
34. intlockState;
35. intwriteOwner;
36. intpid;/*描述一个图形缓冲区的创建者的PID*/
38. #ifdef__cplusplus
39. staticconstintsNumInts=9;/*有9个整数变量*/
40. staticconstintsNumFds=1;/*有1个文件描述符*/
41. staticconstintsMagic=0x3141592;
43. private_handle_t(intfd,intsize,intflags):
44. fd(fd),magic(sMagic),flags(flags),size(size),offset(0),
45. phys(0),base(0),lockState(0),writeOwner(0),pid(getpid())
46. {
47. version=sizeof(native_handle);
48. numInts=sNumInts;
49. numFds=sNumFds;
50. }
51. ~private_handle_t(){
52. magic=0;
53. }
55. boolusesPhysicallyContiguousMemory(){
56. return(flags&PRIV_FLAGS_USES_PMEM)!=0;
57. }
59. /*用来验证一个native_handle_t指针是否指向了一个private_handle_t结构体*/
60. staticintvalidate(constnative_handle*h){
61. constprivate_handle_t*hnd=(constprivate_handle_t*)h;
62. if(!h||h->version!=sizeof(native_handle)||
63. h->numInts!=sNumInts||h->numFds!=sNumFds||
64. hnd->magic!=sMagic)
65. {
66. LOGE("invalidgrallochandle(at%p)",h);
67. return-EINVAL;
68. }
69. return0;
70. }
72. staticprivate_handle_t*dynamicCast(constnative_handle*in){
73. if(validate(in)==0){
74. return(private_handle_t*)in;
75. }
76. returnNULL;
77. }
78. #endif
79. };

图形缓冲区的操作接口由结构 struct gralloc_module_t定义：

[cpp] view plain copy

1. typedefstructgralloc_module_t{
2. structhw_module_tcommon;
4. /*注册一个图形缓冲区，这个指定的图形缓冲区使用一个buffer_handle_t句柄来描述*/
5. int(*registerBuffer)(structgralloc_module_tconst*module,
6. buffer_handle_thandle);
8. /*注销一个图形缓冲区*/
9. int(*unregisterBuffer)(structgralloc_module_tconst*module,
10. buffer_handle_thandle);
12. /*用来锁定一个图形缓冲区并将缓冲区映射到用户进程
13. *在锁定一块图形缓冲区的时候，可以指定要锁定的图形绘冲区的位置以及大小
14. *这是通过参数l、t、w和h来指定的，其中，参数l和t指定的是要访问的图形缓冲区的左上角位置
15. *而参数w和h指定的是要访问的图形缓冲区的宽度和长度
16. *锁定之后，就可以获得由参数参数l、t、w和h所圈定的一块缓冲区的起始地址，保存在输出参数vaddr中
17. *另一方面，在访问完成一块图形缓冲区之后，需要解除这块图形缓冲区的锁定*/
18. int(*lock)(structgralloc_module_tconst*module,
19. buffer_handle_thandle,intusage,
20. intl,intt,intw,inth,
21. void**vaddr);
23. int(*unlock)(structgralloc_module_tconst*module,
24. buffer_handle_thandle);
26. int(*perform)(structgralloc_module_tconst*module,
27. intoperation,...);
29. /*reservedforfutureuse*/
30. void*reserved_proc[7];
31. }gralloc_module_t;

gralloc 设备则用结构struct alloc_device_t 来描述，其定义如下：

[cpp] view plain copy

1. typedefstructalloc_device_t{
2. structhw_device_tcommon;
4. /*申请图形缓冲区的内存空间*/
5. int(*alloc)(structalloc_device_t*dev,intw,inth,intformat,intusage,buffer_handle_t*handle,int*stride);
7. /*释放图形缓冲区的内存空间*/
8. int(*free)(structalloc_device_t*dev,buffer_handle_thandle);
9. }alloc_device_t;

帧缓冲设备则采用结构 struct framebuffer_device_t 描述： [cpp] view plain copy

1. typedefstructframebuffer_device_t{
2. structhw_device_tcommon;
4. constuint32_tflags;/*用来记录系统帧缓冲区的标志*/
6. constuint32_twidth;/*lcd显示区域的像素点数*/
7. constuint32_theight;
9. constintstride;/*描述设备显示屏的一行有多少个像素点*/
11. /*描述系统帧缓冲区的像素格式,主要有HAL_PIXEL_FORMAT_RGBX_8888和HAL_PIXEL_FORMAT_RGB_565两种*/
12. constintformat;
14. constfloatxdpi;
15. constfloatydpi;
16. constfloatfps;/*lcd刷新率*/
17. constintminSwapInterval;/*交换两帧图像的最小间隔时间*/
18. constintmaxSwapInterval;/*交换两帧图像的最大间隔时间*/
20. intreserved[8];
22. /*设置帧交换间隔*/
23. int(*setSwapInterval)(structframebuffer_device_t*window,intinterval);
25. /*设置帧缓冲区的更新区域*/
26. int(*setUpdateRect)(structframebuffer_device_t*window,intleft,inttop,intwidth,intheight);
28. /*用来将图形缓冲区buffer的内容渲染到帧缓冲区中去，即显示在设备的显示屏中去*/
29. int(*post)(structframebuffer_device_t*dev,buffer_handle_tbuffer);
31. /*用来通知fb设备device，图形缓冲区的组合工作已经完成*/
32. int(*compositionComplete)(structframebuffer_device_t*dev);
34. void*reserved_proc[8];
35. }framebuffer_device_t;

其中成员函数 post 对应用程序来说是最重要的接口，它将完成数据写入显存的工作。

2、gralloc 模块

HAL 中通过hw_get_module 接口加载指定 id 的模块，并获得一个hw_module_t 结构来打开设备，流程如下：

[cpp] view plain copy

1. #defineHAL_LIBRARY_PATH1"/system/lib/hw"
2. #defineHAL_LIBRARY_PATH2"/vendor/lib/hw"
4. staticconstchar*variant_keys[]={
5. "ro.hardware",/*Thisgoesfirstsothatitcanpickupadifferentfileontheemulator.*/
6. "ro.product.board",
7. "ro.board.platform",
8. "ro.arch"
9. };
11. staticconstintHAL_VARIANT_KEYS_COUNT=
12. (sizeof(variant_keys)/sizeof(variant_keys[0]));
14. inthw_get_module(constchar*id,conststructhw_module_t**module)
15. {
16. intstatus;
17. inti;
18. conststructhw_module_t*hmi=NULL;
19. charprop[PATH_MAX];
20. charpath[PATH_MAX];
22. /*
23. *Herewerelyonthefactthatcallingdlopenmultipletimeson
24. *thesame.sowillsimplyincrementarefcount(andnotload
25. *anewcopyofthelibrary).
26. *Wealsoassumethatdlopen()isthread-safe.
27. */
29. /*Loopthroughtheconfigurationvariantslookingforamodule*/
30. for(i=0;i<HAL_VARIANT_KEYS_COUNT+1;i++){
31. if(i<HAL_VARIANT_KEYS_COUNT){
32. if(property_get(variant_keys[i],prop,NULL)==0){/*读取variant_keys数组指定的属性值*/
33. continue;
34. }
35. snprintf(path,sizeof(path),"%s/%s.%s.so",/*格式化模块名和路径，如：/system/lib/hw/gralloc.xxx.so*/
36. HAL_LIBRARY_PATH1,id,prop);
37. if(access(path,R_OK)==0)break;
39. snprintf(path,sizeof(path),"%s/%s.%s.so",
40. HAL_LIBRARY_PATH2,id,prop);
41. if(access(path,R_OK)==0)break;
42. }else{
43. snprintf(path,sizeof(path),"%s/%s.default.so",
44. HAL_LIBRARY_PATH1,id);
45. if(access(path,R_OK)==0)break;
46. }
47. }
49. status=-ENOENT;
50. if(i<HAL_VARIANT_KEYS_COUNT+1){
51. /*loadthemodule,ifthisfails,we'redoomed,andweshouldnottrytoloadadifferentvariant.*/
52. status=load(id,path,module);/*加载模块*/
53. }
55. returnstatus;
56. }

函数会在/system/lib/hw 或者/vendor/lib/hw 目录中去寻找gralloc.xxx.so 文件，如果找到了就调用load接口完成加载。最终会调用gralloc_device_open完成 gralloc 设备成员的初始化：

[cpp] view plain copy

1. intgralloc_device_open(consthw_module_t*module,constchar*name,
2. hw_device_t**device)
3. {
4. intstatus=-EINVAL;
5. if(!strcmp(name,GRALLOC_HARDWARE_GPU0)){
6. gralloc_context_t*dev;
7. dev=(gralloc_context_t*)malloc(sizeof(*dev));
9. /*initializeourstatehere*/
10. memset(dev,0,sizeof(*dev));
12. /*initializetheprocs*/
13. dev->device.common.tag=HARDWARE_DEVICE_TAG;
14. dev->device.common.version=0;
15. dev->device.common.module=const_cast<hw_module_t*>(module);
16. dev->device.common.close=gralloc_close;
18. dev->device.alloc=gralloc_alloc;
19. dev->device.free=gralloc_free;
21. *device=&dev->device.common;
22. status=0;
23. }else{
24. status=fb_device_open(module,name,device);
25. }
27. returnstatus;
28. }

在 android 系统中，所有的图形缓冲区都是由 SurfaceFlinger 服务分配的，在系统帧缓冲区中分配的图形缓冲区只在 SurfaceFlinger 服务中使用，而在内存中分配的图形缓冲区既可以在 SurfaceFlinger 服务中使用，也可以在其它的应用程序中使用，当应用程序请求 SurfaceFlinger 服务分配图形缓冲区时会发生 两次映射：服务所在的进程首先会将申请到的缓冲区映射至服务的地址空间，然后应用程序使用这个图形缓冲时再将其映射至应用程序的地址空间。分配函数的实现如下： [cpp] view plain copy

1. staticintgralloc_alloc_framebuffer(alloc_device_t*dev,size_tsize,intusage,buffer_handle_t*pHandle)
2. {
3. private_module_t*m=reinterpret_cast<private_module_t*>(
4. dev->common.module);
5. pthread_mutex_lock(&m->lock);
6. interr=gralloc_alloc_framebuffer_locked(dev,size,usage,pHandle);
7. pthread_mutex_unlock(&m->lock);
8. returnerr;
9. }
11. staticintgralloc_alloc_buffer(alloc_device_t*dev,size_tsize,intusage,buffer_handle_t*pHandle)
12. {
13. interr=0;
14. intfd=-1;
16. size=roundUpToPageSize(size);
18. fd=ashmem_create_region("gralloc-buffer",size);
19. if(fd<0){
20. LOGE("couldn'tcreateashmem(%s)",strerror(-errno));
21. err=-errno;
22. }
24. if(err==0){
25. private_handle_t*hnd=newprivate_handle_t(fd,size,0);
26. gralloc_module_t*module=reinterpret_cast<gralloc_module_t*>(
27. dev->common.module);
28. err=mapBuffer(module,hnd);
29. if(err==0){
30. *pHandle=hnd;
31. }
32. }
34. LOGE_IF(err,"grallocfailederr=%s",strerror(-err));
36. returnerr;
37. }
39. /*****************************************************************************/
41. staticintgralloc_alloc(alloc_device_t*dev,intw,inth,intformat,intusage,
42. buffer_handle_t*pHandle,int*pStride)
43. {
44. if(!pHandle||!pStride)
45. return-EINVAL;
47. size_tsize,stride;
49. intalign=4;
50. intbpp=0;
51. switch(format){/*一个像素点占用的字节数*/
52. caseHAL_PIXEL_FORMAT_RGBA_8888:
53. caseHAL_PIXEL_FORMAT_RGBX_8888:
54. caseHAL_PIXEL_FORMAT_BGRA_8888:
55. bpp=4;
56. break;
57. caseHAL_PIXEL_FORMAT_RGB_888:
58. bpp=3;
59. break;
60. caseHAL_PIXEL_FORMAT_RGB_565:
61. caseHAL_PIXEL_FORMAT_RGBA_5551:
62. caseHAL_PIXEL_FORMAT_RGBA_4444:
63. bpp=2;
64. break;
65. default:
66. return-EINVAL;
67. }
68. size_tbpr=(w*bpp+(align-1))&~(align-1);
69. size=bpr*h;
70. stride=bpr/bpp;
72. interr;
73. if(usage&GRALLOC_USAGE_HW_FB){
74. err=gralloc_alloc_framebuffer(dev,size,usage,pHandle);/*在系统帧缓冲中分配图形缓冲区*/
75. }else{
76. err=gralloc_alloc_buffer(dev,size,usage,pHandle);/*在内存中分配图形缓冲区*/
77. }
79. if(err<0){
80. returnerr;
81. }
83. *pStride=stride;
84. return0;
85. }

3、fb 模块

在gralloc_device_open 中会根据传递的参数分别初始化两个设备，定义如下：

[cpp] view plain copy

1. #defineGRALLOC_HARDWARE_FB0"fb0"
2. #defineGRALLOC_HARDWARE_GPU0"gpu0"

如果参数不是 "gpu0" 则会调用 fb_device_open初始化 fb 设备，主要流程和打开 gralloc 基本一致，在函数中会通过调用 mapFrameBuffer->mapFrameBufferLocked 获取帧缓存设备的参数并将其设备节点映射到用户空间，流程如下： [cpp] view plain copy

1. intmapFrameBufferLocked(structprivate_module_t*module)
2. {
3. if(module->framebuffer){
4. return0;
5. }
7. charconst*constdevice_template[]={
8. "/dev/graphics/fb%u",
9. "/dev/fb%u",
10. 0};
12. intfd=-1;
13. inti=0;
14. charname[64];
16. while((fd==-1)&&device_template[i]){
17. snprintf(name,64,device_template[i],0);
18. fd=open(name,O_RDWR,0);
19. i++;
20. }
21. if(fd<0)
22. return-errno;
24. structfb_fix_screeninfofinfo;
25. if(ioctl(fd,FBIOGET_FSCREENINFO,&finfo)==-1)/*获取帧缓冲的固定参数*/
26. return-errno;
28. structfb_var_screeninfoinfo;
29. if(ioctl(fd,FBIOGET_VSCREENINFO,&info)==-1)/*获取帧缓冲的可变参数*/
30. return-errno;
32. info.reserved[0]=0;
33. info.reserved[1]=0;
34. info.reserved[2]=0;
35. info.xoffset=0;
36. info.yoffset=0;
37. info.activate=FB_ACTIVATE_NOW;
39. info.bits_per_pixel=32;
40. info.red.offset=16;
41. info.red.length=8;
42. info.green.offset=8;
43. info.green.length=8;
44. info.blue.offset=0;
45. info.blue.length=8;
46. info.transp.offset=24;
47. info.transp.length=8;
49. /*
50. *RequestNUM_BUFFERSscreens(atlest2forpageflipping)
51. */
52. info.yres_virtual=info.yres*NUM_BUFFERS;/*帧缓冲总长度*/
55. uint32_tflags=PAGE_FLIP;/*支持缓冲交换*/
56. if(ioctl(fd,FBIOPAN_DISPLAY,&info)==-1){
57. info.yres_virtual=info.yres;
58. flags&=~PAGE_FLIP;
59. LOGW("FBIOPAN_DISPLAYfailed,pageflippingnotsupported");
60. }
62. if(info.yres_virtual<info.yres*2){
63. /*weneedatleast2forpage-flipping*/
64. info.yres_virtual=info.yres;
65. flags&=~PAGE_FLIP;
66. LOGW("pageflippingnotsupported(yres_virtual=%d,requested=%d)",
67. info.yres_virtual,info.yres*2);
68. }
70. if(ioctl(fd,FBIOGET_VSCREENINFO,&info)==-1)
71. return-errno;
73. intrefreshRate=1000000000000000LLU/
74. (
75. uint64_t(info.upper_margin+info.lower_margin+info.yres)
76. *(info.left_margin+info.right_margin+info.xres)
77. *info.pixclock
78. );/*计算lcd刷新率*/
80. if(refreshRate==0){
81. /*bleagh,badinfofromthedriver*/
82. refreshRate=60*1000;//60Hz
83. }
85. if(int(info.width)<=0||int(info.height)<=0){
86. /*thedriverdoesn'treturnthatinformation,defaultto160dpi*/
87. info.width=((info.xres*25.4f)/160.0f+0.5f);
88. info.height=((info.yres*25.4f)/160.0f+0.5f);
89. }
91. floatxdpi=(info.xres*25.4f)/info.width;
92. floatydpi=(info.yres*25.4f)/info.height;
93. floatfps=refreshRate/1000.0f;
95. LOGI("using(fd=%d)\n"
96. "id=%s\n"
97. "xres=%dpx\n"
98. "yres=%dpx\n"
99. "xres_virtual=%dpx\n"
100. "yres_virtual=%dpx\n"
101. "bpp=%d\n"
102. "r=%2u:%u\n"
103. "g=%2u:%u\n"
104. "b=%2u:%u\n",
105. fd,
106. finfo.id,
107. info.xres,
108. info.yres,
109. info.xres_virtual,
110. info.yres_virtual,
111. info.bits_per_pixel,
112. info.red.offset,info.red.length,
113. info.green.offset,info.green.length,
114. info.blue.offset,info.blue.length
115. );
117. LOGI("width=%dmm(%fdpi)\n"
118. "height=%dmm(%fdpi)\n"
119. "refreshrate=%.2fHz\n",
120. info.width,xdpi,
121. info.height,ydpi,
122. fps
123. );
125. if(ioctl(fd,FBIOGET_FSCREENINFO,&finfo)==-1)
126. return-errno;
128. if(finfo.smem_len<=0)
129. return-errno;
131. module->flags=flags;
132. module->info=info;
133. module->finfo=finfo;
134. module->xdpi=xdpi;
135. module->ydpi=ydpi;
136. module->fps=fps;
138. /*
139. *maptheframebuffer
140. */
142. interr;
143. size_tfbSize=roundUpToPageSize(finfo.line_length*info.yres_virtual);/*帧缓冲大小*/
144. module->framebuffer=newprivate_handle_t(dup(fd),fbSize,
145. private_handle_t::PRIV_FLAGS_USES_PMEM);
147. module->numBuffers=info.yres_virtual/info.yres;/*计算系统帧缓冲的个数*/
148. module->bufferMask=0;
150. void*vaddr=mmap(0,fbSize,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);/*将fb映射到用户空间*/
151. if(vaddr==MAP_FAILED){
152. LOGE("Errormappingtheframebuffer(%s)",strerror(errno));
153. return-errno;
154. }
155. module->framebuffer->base=intptr_t(vaddr);/*帧缓冲的起始虚拟地址*/
156. memset(vaddr,0,fbSize);
157. return0;
158. }

fb 模块最重要的工作就是将应用程序指定的内容写入显存中，是通过函数fb_post 完成的，流程如下：

[cpp] view plain copy

1. /*将图形缓冲区buffer的内容渲染到帧缓冲区中去*/
2. staticintfb_post(structframebuffer_device_t*dev,buffer_handle_tbuffer)
3. {
4. unsignedintphys;
5. void*virt;
6. intpitch;
7. intformat;
9. /*首先验证参数handle指向的一块图形缓冲区的确是由Gralloc模块分配的*/
10. if(private_handle_t::validate(buffer)<0)
11. return-EINVAL;
13. fb_context_t*ctx=(fb_context_t*)dev;
15. private_handle_tconst*hnd=reinterpret_cast<private_handle_tconst*>(buffer);/*图形缓冲区*/
16. private_module_t*m=reinterpret_cast<private_module_t*>(dev->common.module);/*帧缓冲区*/
18. if(m->currentBuffer){/*当前正在渲染的图形缓冲区*/
19. m->base.unlock(&m->base,m->currentBuffer);
20. m->currentBuffer=0;
21. }
23. if(hnd->flags&private_handle_t::PRIV_FLAGS_FRAMEBUFFER){/*如果图形缓冲区是在系统帧缓冲中分配的*/
24. m->base.lock(&m->base,buffer,/*锁定图像缓冲区*/
25. private_module_t::PRIV_USAGE_LOCKED_FOR_POST,
26. 0,0,m->info.xres,m->info.yres,NULL);
28. constsize_toffset=hnd->base-m->framebuffer->base;/*计算图形缓冲区与帧缓冲的偏移*/
29. /*将作为参数的fb_var_screeninfo结构体的成员变量activate的值设置FB_ACTIVATE_VBL
30. *表示要等到下一个垂直同步事件出现时，再将当前要渲染的图形缓冲区的内容绘制出来
31. *这样做的目的是避免出现屏幕闪烁，即避免前后两个图形缓冲区的内容各有一部分同时出现屏幕中*/
32. m->info.activate=FB_ACTIVATE_VBL;
33. m->info.yoffset=offset/m->finfo.line_length;/*得到偏移的起始行*/
35. if(ioctl(m->framebuffer->fd,FBIOPAN_DISPLAY,&m->info)==-1){/*刷新显示内容*/
36. LOGE("FBIOPAN_DISPLAYfailed");
37. m->base.unlock(&m->base,buffer);
38. return-errno;
39. }
41. if(UNLIKELY(mDebugFps)){
42. debugShowFPS();
43. }
45. #ifdefSNAPSHOT
46. dumpfile((void*)hnd->base,m->info.xres,m->info.yres);/*dump帧缓冲*/
47. #endif
48. m->currentBuffer=buffer;/*设置当前图形缓冲区*/
49. }else{/*如果图形缓冲区是在内存中分配的*/
50. /*Ifwecan'tdothepage_flip,justcopythebuffertothefront
51. *FIXME:usecopybitHALinsteadofmemcpy*/
52. LOGD("copybit.\n");
53. void*fb_vaddr;
54. void*buffer_vaddr;
56. /*将帧缓冲整个锁定*/
57. m->base.lock(&m->base,m->framebuffer,
58. GRALLOC_USAGE_SW_WRITE_RARELY,
59. 0,0,m->info.xres,m->info.yres,
60. &fb_vaddr);
62. /*将图形缓冲整个锁定*/
63. m->base.lock(&m->base,buffer,
64. GRALLOC_USAGE_SW_READ_RARELY,
65. 0,0,m->info.xres,m->info.yres,
66. &buffer_vaddr);
68. /*将图形缓冲的内容拷贝到帧缓冲中即显示到lcd*/
69. memcpy(fb_vaddr,buffer_vaddr,m->finfo.line_length*m->info.yres);
71. m->base.unlock(&m->base,buffer);/*解锁*/
72. m->base.unlock(&m->base,m->framebuffer);
73. }
75. return0;
76. }
    

更多相关文章

1. Android帧缓冲区（Frame Buffer）硬件抽象层（HAL）模块Gralloc的实现原
2. Android(安卓)直接显示yuv数据 通过Awesomeplayer方式直接显示（三
3. android-opengles3.0开发-2-绘制图形
4. 我是一只忍者神龟.
5. Android图形图画学习(11)——颜色相关
6. 视频学习笔记：Android(安卓)ffmpeg解码多路h264视频并显示
7. android立体图形——三棱锥
8. android 解决java.nio.BufferOverflowException 异常
9. Android——图形系统

随机推荐

1. 【Android】保存Fragment切换状态
2. Android(安卓)Framework 调试 (java)
3. android:用getIdentifier()获取资源Id
4. 上官网学android之五（Managing the Activi
5. Android(安卓)MIFARE读写器详解2
6. android 自定义命名空间
7. 搬砖：深入浅出 - Android系统移植与平台开
8. Android(安卓)Glide图片加载框架图片变色
9. android 客户端上传到第三方应用市场
10. ImageLoader源码解析