Android GUI系统学习1：Gralloc

Gralloc模块是从Android Eclair（android 2.1）开始加入的一个HAL模块，Gralloc的含义为是Graphics Alloc(图形分配)。他对上为libui提供服务，为其分配显存，刷新显示等。对下对framebuffer进行管理。

gralloc代码通常位于hardware/libhardware/modules/gralloc目录下。包含以下几个文件：

Android.mk  framebuffer.cpp  gralloc.cpp  gralloc_priv.h  gr.h  mapper.cpp

另外，与其相关的头文件位于hardware/libhardware/include/hardware，涉及fb.h和gralloc.h。

下面从gralloc的调用开始学习gralloc的代码。代码基于android4.4。

gralloc的调用是从FramebufferNativeWindow.cpp的构造函数开始的。FramebufferNativeWindow实现FrameBuffer的管理，它主要被SurfaceFlinger使用，也可以被OpenGL Native程序使用。在本质上，它在Framebuffer之上实现了一个ANativeWindow，目前它只管理两个buffers:front and back buffer。

如下所示(FramebufferNativeWindow.cpp)：

FramebufferNativeWindow::FramebufferNativeWindow() 
 : BASE(), fbDev(0), grDev(0), mUpdateOnDemand(false) 
 { 
 hw_module_t const* module; 
 if (hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module) == 0) { 
 int stride; 
 int err; 
 int i; 
 err = framebuffer_open(module, &fbDev); 
 ALOGE_IF(err, "couldn't open framebuffer HAL (%s)", strerror(-err)); 
  
err = gralloc_open(module, &grDev); 
 ALOGE_IF(err, "couldn't open gralloc HAL (%s)", strerror(-err)); 
  
// bail out if we can't initialize the modules 
 if (!fbDev || !grDev) 
 return; 
  
mUpdateOnDemand = (fbDev->setUpdateRect != 0); 
  
// initialize the buffer FIFO 
 if(fbDev->numFramebuffers >= MIN_NUM_FRAME_BUFFERS && 
 fbDev->numFramebuffers <= MAX_NUM_FRAME_BUFFERS){ 
mNumBuffers = fbDev->numFramebuffers; 
 } else { 
 mNumBuffers = MIN_NUM_FRAME_BUFFERS; 
 } 
 mNumFreeBuffers = mNumBuffers; 
 mBufferHead = mNumBuffers-1; 
  
/* 
 * This does not actually change the framebuffer format. It merely 
 * fakes this format to surfaceflinger so that when it creates 
 * framebuffer surfaces it will use this format. It's really a giant 
 * HACK to allow interworking with buggy gralloc+GPU driver 
 * implementations. You should *NEVER* need to set this for shipping 
 * devices. 
 */ 
 #ifdef FRAMEBUFFER_FORCE_FORMAT 
 *((uint32_t *)&fbDev->format) = FRAMEBUFFER_FORCE_FORMAT; 
 #endif 
  
for (i = 0; i < mNumBuffers; i++) { buffers[i] = new NativeBuffer
( fbDev->width, fbDev->height, fbDev->format, GRALLOC_USAGE_HW_FB); 
 } 
  
for (i = 0; i < mNumBuffers; i++) { err = grDev->alloc(grDev, 
 fbDev->width, fbDev->height, fbDev->format, 
 GRALLOC_USAGE_HW_FB, &buffers[i]->handle, &buffers[i]->stride); 
  
ALOGE_IF(err, "fb buffer %d allocation failed w=%d, h=%d, err=%s", 
 i, fbDev->width, fbDev->height, strerror(-err)); 
  
if (err) 
 { 
 mNumBuffers = i; 
 mNumFreeBuffers = i; 
 mBufferHead = mNumBuffers-1; 
 break; 
 } 
 } 
  
const_cast<uint32_t&>(ANativeWindow::flags) = fbDev->flags; 
 const_cast<float&>(ANativeWindow::xdpi) = fbDev->xdpi; 
 const_cast<float&>(ANativeWindow::ydpi) = fbDev->ydpi; 
 const_cast<int&>(ANativeWindow::minSwapInterval) = 
 fbDev->minSwapInterval; 
 const_cast<int&>(ANativeWindow::maxSwapInterval) = 
 fbDev->maxSwapInterval; 
 } else { 
 ALOGE("Couldn't get gralloc module"); 
 } 
  
ANativeWindow::setSwapInterval = setSwapInterval; 
 ANativeWindow::dequeueBuffer = dequeueBuffer; 
 ANativeWindow::queueBuffer = queueBuffer; 
 ANativeWindow::query = query; 
 ANativeWindow::perform = perform; 
  
ANativeWindow::dequeueBuffer_DEPRECATED = dequeueBuffer_DEPRECATED; 
 ANativeWindow::lockBuffer_DEPRECATED = lockBuffer_DEPRECATED; 
 ANativeWindow::queueBuffer_DEPRECATED = queueBuffer_DEPRECATED; 
 } 

这里会先根据gralloc的module ID来得到hw_module_t结构。hw_get_module->hw_get_module_by_class。在hw_get_module_by_class里面，首先根据平台配置找到gralloc动态库的位置，默认使用gralloc.default.so。
参见以下代码(hardware.c)：

for (i=0 ; i<HAL_VARIANT_KEYS_COUNT+1 ; i++) { 
        if (i < HAL_VARIANT_KEYS_COUNT) { 
            if (property_get(variant_keys[i], prop, NULL) == 0) { 
                continue; 
            } 
            snprintf(path, sizeof(path), "%s/%s.%s.so", 
                     HAL_LIBRARY_PATH2, name, prop); 
            if (access(path, R_OK) == 0) break; 
  
            snprintf(path, sizeof(path), "%s/%s.%s.so", 
                     HAL_LIBRARY_PATH1, name, prop); 
            if (access(path, R_OK) == 0) break; 
        } else { 
            snprintf(path, sizeof(path), "%s/%s.default.so", 
                     HAL_LIBRARY_PATH2, name); 
            if (access(path, R_OK) == 0) break; 
  
            snprintf(path, sizeof(path), "%s/%s.default.so", 
                     HAL_LIBRARY_PATH1, name); 
            if (access(path, R_OK) == 0) break; 
        } 
    } 
 status = -ENOENT; 
 if (i < HAL_VARIANT_KEYS_COUNT+1) { 
 /* load the module, if this fails, we're doomed, and we should not try 
 * to load a different variant. */ 
 status = load(class_id, path, module); 
 } 

找到gralloc库的路径后，会调用load函数，在load函数中使用dlopen打开找到的库，并根据HAL_MODULE_INFO_SYM_AS_STR（其值为HMI）获取到hw_module_t（即HAL_MODULE_INFO_SYM）结构体指针，以及把dlopen返回的handle保存在hw_module_t中。而hw_module_t HMI
结构是一个全局结构，在gralloc.cpp中已经得到初始化了。这也是为什么每一个HAL模块都要定义并初始化一个名字为HAL_MODULE_INFO_SYM的hw_module_t结构

struct private_module_t HAL_MODULE_INFO_SYM = { 
    base: { 
        common: { 
            tag: HARDWARE_MODULE_TAG, 
            version_major: 1, 
            version_minor: 0, 
            id: GRALLOC_HARDWARE_MODULE_ID, 
            name: "Graphics Memory Allocator Module", 
            author: "The Android Open Source Project", 
            methods: &gralloc_module_methods 
        }, 
        registerBuffer: gralloc_register_buffer, 
        unregisterBuffer: gralloc_unregister_buffer, 
        lock: gralloc_lock, 
        unlock: gralloc_unlock, 
    }, 
    framebuffer: 0, 
    flags: 0, 
    numBuffers: 0, 
    bufferMask: 0, 
    lock: PTHREAD_MUTEX_INITIALIZER, 
    currentBuffer: 0, 
}; 

#p#

回过头，回到FramebufferNativeWindow的构造函数处，接下来调用了err = framebuffer_open(module, &fbDev);framebuffer_open定义在fb.h中，是一个inline函数，其实最终调用了就是上面结构体中初始化的open函数，open函数指向gralloc_device_open，其实现为(gralloc.cpp)：

int gralloc_device_open(const hw_module_t* module, const char* name, hw_device_t** device) 
{ 
    int status = -EINVAL; 
    if (!strcmp(name, GRALLOC_HARDWARE_GPU0)) { 
        gralloc_context_t *dev; 
        dev = (gralloc_context_t*)malloc(sizeof(*dev)); 
  
        /* initialize our state here */ 
        memset(dev, 0, sizeof(*dev)); 
  
        /* initialize the procs */ 
        dev->device.common.tag = HARDWARE_DEVICE_TAG; 
        dev->device.common.version = 0; 
        dev->device.common.module = const_cast<hw_module_t*>(module); 
        dev->device.common.close = gralloc_close; 
  
        dev->device.alloc   = gralloc_alloc; 
        dev->device.free    = gralloc_free; 
  
        *device = &dev->device.common; 
        status = 0; 
    } else { 
        status = fb_device_open(module, name, device); 
    } 
    return status; 
} 

fb_device_open的定义如下所示(framebuffer.cpp)：

int fb_device_open(hw_module_t const* module, const char* name, 
        hw_device_t** device) 
{ 
    int status = -EINVAL; 
    if (!strcmp(name, GRALLOC_HARDWARE_FB0)) { 
        /* initialize our state here */ 
        fb_context_t *dev = (fb_context_t*)malloc(sizeof(*dev)); 
        memset(dev, 0, sizeof(*dev)); 
  
        /* initialize the procs */ 
        dev->device.common.tag = HARDWARE_DEVICE_TAG; 
        dev->device.common.version = 0; 
        dev->device.common.module = const_cast<hw_module_t*>(module); 
        dev->device.common.close = fb_close; 
        dev->device.setSwapInterval = fb_setSwapInterval; 
        dev->device.post            = fb_post; 
        dev->device.setUpdateRect = 0; 
  
        private_module_t* m = (private_module_t*)module; 
        status = mapFrameBuffer(m); 
        if (status >= 0) { 
            int stride = m->finfo.line_length / (m->info.bits_per_pixel >> 3); 
            int format = (m->info.bits_per_pixel == 32) 
                         ? HAL_PIXEL_FORMAT_RGBX_8888 
                         : HAL_PIXEL_FORMAT_RGB_565; 
            const_cast<uint32_t&>(dev->device.flags) = 0; 
            const_cast<uint32_t&>(dev->device.width) = m->info.xres; 
            const_cast<uint32_t&>(dev->device.height) = m->info.yres; 
            const_cast<int&>(dev->device.stride) = stride; 
            const_cast<int&>(dev->device.format) = format; 
            const_cast<float&>(dev->device.xdpi) = m->xdpi; 
            const_cast<float&>(dev->device.ydpi) = m->ydpi; 
            const_cast<float&>(dev->device.fps) = m->fps; 
            const_cast<int&>(dev->device.minSwapInterval) = 1; 
            const_cast<int&>(dev->device.maxSwapInterval) = 1; 
            *device = &dev->device.common; 
        } 
    } 
    return status; 
} 

接下来的gralloc_open也是调用了gralloc_device_open，只不过name参数一个是GRALLOC_HARDWARE_GPU0，而另外一个是GRALLOC_HARDWARE_FB0，这两个函数分别得到alloc_device_t 和 framebuffer_device_t结构。到现在为止，gralloc模块的三个主要结构体，gralloc_module_t，alloc_device_t，framebuffer_device_t都已经获取到了。其中在fb_device_open函数中会获取实际的framebuffer设备（通常是/dev/graphics/fb0）的一些重要参数以及能力，比如分辨率信息以及支持多少个缓冲等，另外会把framebuffer映射到内测的地址保存到alloc_module_t中。android一般使用的都是双缓冲机制。具体代码如下（framebuffer.cpp），其中涉及到对private_module_t中一些成员的完善，涉及到gralloc_module_t以及private_handle_t等，其定义在gralloc_priv.h中，这两个结构中都保存了framebuffer的一些私有信息。

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]; 
  
while ((fd==-1) && device_template[i]) { 
snprintf(name, 64, device_template[i], 0); 
fd = open(name, O_RDWR, 0); 
i++; 
} 
if (fd < 0) 
return -errno; 
  
struct fb_fix_screeninfo finfo; 
if (ioctl(fd, FBIOGET_FSCREENINFO, &finfo) == -1) 
return -errno; 
  
struct fb_var_screeninfo info; 
if (ioctl(fd, FBIOGET_VSCREENINFO, &info) == -1) 
return -errno; 
  
info.reserved[0] = 0; 
info.reserved[1] = 0; 
info.reserved[2] = 0; 
info.xoffset = 0; 
info.yoffset = 0; 
info.activate = FB_ACTIVATE_NOW; 
  
/* 
* Request NUM_BUFFERS screens (at lest 2 for page flipping) 
*/ 
info.yres_virtual = info.yres * NUM_BUFFERS; 
uint32_t flags = PAGE_FLIP; 
if (ioctl(fd, FBIOPUT_VSCREENINFO, &info) == -1) { 
info.yres_virtual = info.yres; 
flags &= ~PAGE_FLIP; 
ALOGW("FBIOPUT_VSCREENINFO failed, page flipping not supported"); 
} 
  
if (info.yres_virtual < info.yres * 2) { 
// we need at least 2 for page-flipping 
info.yres_virtual = info.yres; 
flags &= ~PAGE_FLIP; 
ALOGW("page flipping not supported (yres_virtual=%d, requested=%d)", 
info.yres_virtual, info.yres*2); 
} 
  
if (ioctl(fd, FBIOGET_VSCREENINFO, &info) == -1) 
return -errno; 
  
uint64_t refreshQuotient = 
( 
uint64_t( info.upper_margin + info.lower_margin + info.yres ) 
* ( info.left_margin + info.right_margin + info.xres ) 
* info.pixclock 
); 
  
/* Beware, info.pixclock might be 0 under emulation, so avoid a 
* division-by-0 here (SIGFPE on ARM) */ 
int refreshRate = refreshQuotient > 0 ? (int)(1000000000000000LLU / refreshQuotient) : 0; 
  
if (refreshRate == 0) { 
// bleagh, bad info from the driver 
refreshRate = 60*1000; // 60 Hz 
} 
  
if (int(info.width) <= 0 || int(info.height) <= 0) { 
// the driver doesn't return that information 
// default to 160 dpi 
info.width = ((info.xres * 25.4f)/160.0f + 0.5f); 
info.height = ((info.yres * 25.4f)/160.0f + 0.5f); 
} 
  
float xdpi = (info.xres * 25.4f) / info.width; 
float ydpi = (info.yres * 25.4f) / info.height; 
float fps = refreshRate / 1000.0f; 
  
ALOGI( "using (fd=%d)\n" 
"id = %s\n" 
"xres = %d px\n" 
"yres = %d px\n" 
"xres_virtual = %d px\n" 
"yres_virtual = %d px\n" 
"bpp = %d\n" 
"r = %2u:%u\n" 
"g = %2u:%u\n" 
"b = %2u:%u\n", 
fd, 
finfo.id, 
info.xres, 
info.yres, 
info.xres_virtual, 
info.yres_virtual, 
info.bits_per_pixel, 
info.red.offset, info.red.length, 
info.green.offset, info.green.length, 
info.blue.offset, info.blue.length 
); 
  
ALOGI( "width = %d mm (%f dpi)\n" 
"height = %d mm (%f dpi)\n" 
"refresh rate = %.2f Hz\n", 
info.width, xdpi, 
info.height, ydpi, 
fps 
); 
if (ioctl(fd, FBIOGET_FSCREENINFO, &finfo) == -1) 
return -errno; 
  
if (finfo.smem_len <= 0) 
return -errno; 
module->flags = flags; 
module->info = info; 
module->finfo = finfo; 
module->xdpi = xdpi; 
module->ydpi = ydpi; 
module->fps = fps; 
  
/* 
* map the framebuffer 
*/ 
  
int err; 
size_t fbSize = roundUpToPageSize(finfo.line_length * info.yres_virtual); 
module->framebuffer = new private_handle_t(dup(fd), fbSize, 0); 
  
module->numBuffers = info.yres_virtual / info.yres; 
module->bufferMask = 0; 
  
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; 
} 
module->framebuffer->base = intptr_t(vaddr); 
memset(vaddr, 0, fbSize); 
return 0; 
} 

由上面函数看出，mapFrameBufferLocked主要做了下面几件事情：

1. 打开framebuffer设备

2. 获取 fb_fix_screeninfo and fb_var_screeninfo

3. refill fb_var_screeninfo

4. 判断是否支持PAGE_FLIP

5. 计算刷新率

6. 打印gralloc信息

7. 填充private_module_t

8. mmap the framebuffer

#p#

看之前的HAL模块比如Camera模块，有一个hw_module_t结构和一个hw_device_t结构，而这里的gralloc模块却包含了两个hw_device_t结构，一个alloc_device_t和一个framebuffer_device_t结构。先看framebuffer_device_t定义：

framebuffer_device_t（fb.h）：

typedef struct framebuffer_device_t { 
struct hw_device_t common; 
  
/* flags describing some attributes of the framebuffer */ 
const uint32_t flags; 
  
/* dimensions of the framebuffer in pixels */ 
const uint32_t width; 
const uint32_t height; 
  
/* frambuffer stride in pixels */ 
const int stride; 
  
/* framebuffer pixel format */ 
const int format; 
  
/* resolution of the framebuffer's display panel in pixel per inch*/ 
const float xdpi; 
const float ydpi; 
  
/* framebuffer's display panel refresh rate in frames per second */ 
const float fps; 
  
/* min swap interval supported by this framebuffer */ 
const int minSwapInterval; 
  
/* max swap interval supported by this framebuffer */ 
const int maxSwapInterval; 
  
/* Number of framebuffers supported*/ 
const int numFramebuffers; 
  
int reserved[7]; 
  
/* 
* requests a specific swap-interval (same definition than EGL) 
* 
* Returns 0 on success or -errno on error. 
*/ 
int (*setSwapInterval)(struct framebuffer_device_t* window, 
int interval); 
  
/* 
* This hook is OPTIONAL. 
* 
* It is non NULL If the framebuffer driver supports "update-on-demand" 
* and the given rectangle is the area of the screen that gets 
* updated during (*post)(). 
* 
* This is useful on devices that are able to DMA only a portion of 
* the screen to the display panel, upon demand -- as opposed to 
* constantly refreshing the panel 60 times per second, for instance. 
* 
* Only the area defined by this rectangle is guaranteed to be valid, that 
* is, the driver is not allowed to post anything outside of this 
* rectangle. 
* 
* The rectangle evaluated during (*post)() and specifies which area 
* of the buffer passed in (*post)() shall to be posted. 
* 
* return -EINVAL if width or height <=0, or if left or top < 0 
*/ 
int (*setUpdateRect)(struct framebuffer_device_t* window, 
int left, int top, int width, int height); 
  
/* 
* Post <buffer> to the display (display it on the screen) 
* The buffer must have been allocated with the 
* GRALLOC_USAGE_HW_FB usage flag. 
* buffer must be the same width and height as the display and must NOT 
* be locked. 
* 
* The buffer is shown during the next VSYNC. 
* 
* If the same buffer is posted again (possibly after some other buffer), 
* post() will block until the the first post is completed. 
* 
* Internally, post() is expected to lock the buffer so that a 
* subsequent call to gralloc_module_t::(*lock)() with USAGE_RENDER or 
* USAGE_*_WRITE will block until it is safe; that is typically once this 
* buffer is shown and another buffer has been posted. 
* 
* Returns 0 on success or -errno on error. 
*/ 
int (*post)(struct framebuffer_device_t* dev, buffer_handle_t buffer); 
/* 
* The (*compositionComplete)() method must be called after the 
* compositor has finished issuing GL commands for client buffers. 
*/ 
  
int (*compositionComplete)(struct framebuffer_device_t* dev); 
  
/* 
* This hook is OPTIONAL. 
* 
* If non NULL it will be caused by SurfaceFlinger on dumpsys 
*/ 
void (*dump)(struct framebuffer_device_t* dev, char *buff, int buff_len); 
  
/* 
* (*enableScreen)() is used to either blank (enable=0) or 
* unblank (enable=1) the screen this framebuffer is attached to. 
* 
* Returns 0 on success or -errno on error. 
*/ 
int (*enableScreen)(struct framebuffer_device_t* dev, int enable); 
  
void* reserved_proc[6]; 
  
} framebuffer_device_t; 

从这个结构看以看出，framebuffer_device_t里面主要保存了framebuffer相关的一些信息，例如分辨率，刷新率，framebuffer的数量等，另外，里面定义了一些操作framebuffer的函数，一下简单介绍其中几个函数。

1. static int fb_setSwapInterval(struct framebuffer_device_t* dev, int interval)

这个函数基本没有用，因为maxSwapInterval=minSwapInterval= 1；

2. int (*setUpdateRect)(struct framebuffer_device_t* window, int left, int top, int width, int height);

这个函数是局部刷新用的，默认没有启用。和平台有关。

3. int (*post)(struct framebuffer_device_t* dev, buffer_handle_t buffer);

这个是最关键的函数。用来将图形缓冲区buffer的内容渲染到帧缓冲区中去，即显示在设备的显示屏中去。函数实现如下：

static int fb_post(struct framebuffer_device_t* dev, buffer_handle_t buffer) 
{ 
if (private_handle_t::validate(buffer) < 0) 
return -EINVAL; 
  
fb_context_t* ctx = (fb_context_t*)dev; 
  
private_handle_t const* hnd = reinterpret_cast<private_handle_t const*>(buffer); 
private_module_t* m = reinterpret_cast<private_module_t*>( 
dev->common.module); 
  
if (hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER) { 
const size_t offset = hnd->base - m->framebuffer->base; 
m->info.activate = FB_ACTIVATE_VBL; 
m->info.yoffset = offset / m->finfo.line_length; 
if (ioctl(m->framebuffer->fd, FBIOPUT_VSCREENINFO, &m->info) == -1) { 
ALOGE("FBIOPUT_VSCREENINFO failed"); 
m->base.unlock(&m->base, buffer); 
return -errno; 
} 
m->currentBuffer = buffer; 
  
} else { 
// If we can't do the page_flip, just copy the buffer to the front 
// FIXME: use copybit HAL instead of memcpy 
  
void* fb_vaddr; 
void* buffer_vaddr; 
  
m->base.lock(&m->base, m->framebuffer, 
GRALLOC_USAGE_SW_WRITE_RARELY, 
0, 0, m->info.xres, m->info.yres, 
&fb_vaddr); 
  
m->base.lock(&m->base, buffer, 
GRALLOC_USAGE_SW_READ_RARELY, 
0, 0, m->info.xres, m->info.yres, 
&buffer_vaddr); 
  
memcpy(fb_vaddr, buffer_vaddr, m->finfo.line_length * m->info.yres); 
  
m->base.unlock(&m->base, buffer); 
m->base.unlock(&m->base, m->framebuffer); 
} 
  
return 0; 
} 

从fb_post的函数定义可以看出，其实现方式有两种方式，***种方式是把Framebuffer的后buffer切为前buffer，然后通过IOCTRL机制告诉FB驱动切换DMA源地地址。

具体原理是这样的：当private_handle_t结构体hnd所描述的图形缓冲区是在系统帧缓冲区中分配的时候，即这个图形缓冲区的标志值flags的PRIV_FLAGS_FRAMEBUFFER位等于1的时候，我们是不需要将图形缓冲区的内容拷贝到系统帧缓冲区去的，因为我们将内容写入到图形缓冲区的时候，已经相当于是将内容写入到了系统帧缓冲区中去了。虽然在这种情况下，我们不需要将图形缓冲区的内容拷贝到系统帧缓冲区去，但是我们需要告诉系统帧缓冲区设备将要渲染的图形缓冲区作为系统当前的输出图形缓冲区，这样才可以将要渲染的图形缓冲区的内容绘制到设备显示屏来。例如，假设系统帧缓冲区有2个图形缓冲区，当前是以第1个图形缓冲区作为输出图形缓冲区的，这时候如果我们需要渲染第2个图形缓冲区，那么就必须告诉系统帧绘冲区设备，将第2个图形缓冲区作为输出图形缓冲区。这个实现方式的前提是Linux内核必须分配至少两个缓冲区大小的物理内存和实现切换的ioctrol，这个比较快速。

设置系统帧缓冲区的当前输出图形缓冲区是通过IO控制命令FBIOPUT_VSCREENINFO来进行的。IO控制命令FBIOPUT_VSCREENINFO需要一个fb_var_screeninfo结构体作为参数。从前面第3部分的内容可以知道，private_module_t结构体m的成员变量info正好保存在我们所需要的这个fb_var_screeninfo结构体。有了个m->info这个fb_var_screeninfo结构体之后，我们只需要设置好它的成员变量yoffset的值（不用设置成员变量xoffset的值是因为所有的图形缓冲区的宽度是相等的），就可以将要渲染的图形缓冲区设置为系统帧缓冲区的当前输出图形缓冲区。fb_var_screeninfo结构体的成员变量yoffset保存的是当前输出图形缓冲区在整个系统帧缓冲区的纵向偏移量，即Y偏移量。我们只需要将要渲染的图形缓冲区的开始地址hnd->base的值减去系统帧缓冲区的基地址m->framebuffer->base的值，再除以图形缓冲区一行所占据的字节数m->finfo.line_length，就可以得到所需要的Y偏移量。

在执行IO控制命令FBIOPUT_VSCREENINFO之前，还会将作为参数的fb_var_screeninfo结构体的成员变量activate的值设置FB_ACTIVATE_VBL，表示要等到下一个垂直同步事件出现时，再将当前要渲染的图形缓冲区的内容绘制出来。这样做的目的是避免出现屏幕闪烁，即避免前后两个图形缓冲区的内容各有一部分同时出现屏幕中。

第二种方式是利用copy的方式来实现，比较耗时。当private_handle_t结构体hnd所描述的图形缓冲区是在内存中分配的时候，即这个图形缓冲区的标志值flags的PRIV_FLAGS_FRAMEBUFFER位等于0的时候，我们就需要将它的内容拷贝到系统帧缓冲区中去了。这个拷贝的工作是通过调用函数memcpy来完成的。在拷贝之前，我们需要三个参数。***个参数是要渲染的图形缓冲区的起址地址，这个地址保存在参数buffer所指向的一个private_handle_t结构体中。第二个参数是要系统帧缓冲区的基地址，这个地址保存在private_module_t结构体m的成员变量framebuffer所指向的一个private_handle_t结构体中。第三个参数是要拷贝的内容的大小，这个大小就刚好是一个屏幕像素所占据的内存的大小。屏幕高度由m->info.yres来描述，而一行屏幕像素所占用的字节数由m->finfo.line_length来描述，将这两者相乘，就可以得到一个屏幕像素所占据的内存的大小。

在将一块内存缓冲区的内容拷贝到系统帧缓冲区中去之前，需要对这两块缓冲区进行锁定，以保证在拷贝的过程中，这两块缓冲区的内容不会被修改。这个锁定的工作是由Gralloc模块中的函数gralloc_lock来实现的。从前面第1部分的内容可以知道，Gralloc模块中的函数gralloc_lock的地址正好就保存在private_module_t结构体m的成员变量base所描述的一个gralloc_module_t结构体的成员函数lock中。

在调用函数gralloc_lock来锁定一块缓冲区之后，还可以通过***一个输出参数来获得被锁定的缓冲区的开始地址，因此，通过调用函数gralloc_lock来锁定要渲染的图形缓冲区以及系统帧缓冲区，就可以得到前面所需要的***个和第二个参数。

将要渲染的图形缓冲区的内容拷贝到系统帧缓冲区之后，就可以解除前面对它们的锁定了，这个解锁的工作是由Gralloc模块中的函数gralloc_unlock来实现的。从前面第1部分的内容可以知道，Gralloc模块中的函数gralloc_unlock的地址正好就保存在private_module_t结构体m的成员变量base所描述的一个gralloc_module_t结构体的成员函数unlock中。

以上是framebuffer_device_t结构相关的一些内容，其主要作用是渲染图形缓冲区来显示内容。下面在看看alloc_device_t的内容。

#p#

alloc_device_t结构的内容如下：

typedef struct alloc_device_t { 
struct hw_device_t common; 
  
/* 
* (*alloc)() Allocates a buffer in graphic memory with the requested 
* parameters and returns a buffer_handle_t and the stride in pixels to 
* allow the implementation to satisfy hardware constraints on the width 
* of a pixmap (eg: it may have to be multiple of 8 pixels). 
* The CALLER TAKES OWNERSHIP of the buffer_handle_t. 
* 
* If format is HAL_PIXEL_FORMAT_YCbCr_420_888, the returned stride must be 
* 0, since the actual strides are available from the android_ycbcr 
* structure. 
* 
* Returns 0 on success or -errno on error. 
*/ 
  
int (*alloc)(struct alloc_device_t* dev, 
int w, int h, int format, int usage, 
buffer_handle_t* handle, int* stride); 
  
/* 
* (*free)() Frees a previously allocated buffer. 
* Behavior is undefined if the buffer is still mapped in any process, 
* but shall not result in termination of the program or security breaches 
* (allowing a process to get access to another process' buffers). 
* THIS FUNCTION TAKES OWNERSHIP of the buffer_handle_t which becomes 
* invalid after the call. 
* 
* Returns 0 on success or -errno on error. 
*/ 
int (*free)(struct alloc_device_t* dev, 
buffer_handle_t handle); 
  
/* This hook is OPTIONAL. 
* 
* If non NULL it will be caused by SurfaceFlinger on dumpsys 
*/ 
void (*dump)(struct alloc_device_t *dev, char *buff, int buff_len); 
  
void* reserved_proc[7]; 
} alloc_device_t; 

从其结构体成员可以看出，其主要作用是为请求者分配图形缓冲区。先看alloc函数的实现（gralloc.cpp）:

static int gralloc_alloc(alloc_device_t* dev, 
 int w, int h, int format, int usage, 
 buffer_handle_t* pHandle, int* pStride) 
{ 
 if (!pHandle || !pStride) 
 return -EINVAL; 
  
size_t size, stride; 
  
int align = 4; 
 int bpp = 0; 
 switch (format) { 
 case HAL_PIXEL_FORMAT_RGBA_8888: 
 case HAL_PIXEL_FORMAT_RGBX_8888: 
 case HAL_PIXEL_FORMAT_BGRA_8888: 
 bpp = 4; 
 break; 
 case HAL_PIXEL_FORMAT_RGB_888: 
 bpp = 3; 
 break; 
 case HAL_PIXEL_FORMAT_RGB_565: 
 case HAL_PIXEL_FORMAT_RAW_SENSOR: 
 bpp = 2; 
 break; 
 default: 
 return -EINVAL; 
 } 
 size_t bpr = (w*bpp + (align-1)) & ~(align-1); 
 size = bpr * h; 
 stride = bpr / bpp; 
  
int err; 
 if (usage & GRALLOC_USAGE_HW_FB) { 
 err = gralloc_alloc_framebuffer(dev, size, usage, pHandle); 
 } else { 
 err = gralloc_alloc_buffer(dev, size, usage, pHandle); 
 } 
  
if (err < 0) { 
 return err; 
 } 
  
*pStride = stride; 
 return 0; 
} 

参数format用来描述要分配的图形缓冲区的颜色格式，描述一个像素需要几个字节来表示。参数w表示要分配的图形缓冲区所保存的图像的宽度，将它乘以bpp，就可以得到保存一行像素所需要使用的字节数。我们需要将这个字节数对齐到4个字节边界，***得到一行像素所需要的字节数就保存在变量bpr中。

参数h表示要分配的图形缓冲区所保存的图像的高度，将它乘以bpr，就可以得到保存整个图像所需要使用的字节数。将变量bpr的值除以变量bpp的值，就得到要分配的图形缓冲区一行包含有多少个像素点，这个结果需要保存在输出参数pStride中，以便可以返回给调用者。

参数usage用来描述要分配的图形缓冲区的用途。如果是用来在系统帧缓冲区中渲染的，即参数usage的GRALLOC_USAGE_HW_FB位等于1，那么就必须要系统帧缓冲区中分配，否则的话，就在内存中分配。注意，在内存中分配的图形缓冲区，最终是需要拷贝到系统帧缓冲区去的，以便可以将它所描述的图形渲染出来。函数gralloc_alloc_framebuffer用来在系统帧缓冲区中分配图形缓冲区，而函数gralloc_alloc_buffer用来在内存在分配图形缓冲区，接下来我们就来看看这两个函数的实现。

gralloc_alloc_framebuffer最终调用了gralloc_alloc_framebuffer_locked（gralloc.cpp）：

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. 
 int err = mapFrameBufferLocked(m); 
 if (err < 0) { 
 return err; 
 } 
 } 
  
const uint32_t bufferMask = m->bufferMask; 
 const uint32_t numBuffers = m->numBuffers; 
 const size_t bufferSize = m->finfo.line_length * m->info.yres; 
 if (numBuffers == 1) { 
 // If we have only one buffer, we never use page-flipping. Instead, 
 // we return a regular buffer which will be memcpy'ed to the main 
 // screen when post is called. 
 int newUsage = (usage & ~GRALLOC_USAGE_HW_FB) | GRALLOC_USAGE_HW_2D; 
 return gralloc_alloc_buffer(dev, bufferSize, newUsage, pHandle); 
 } 
  
if (bufferMask >= ((1LU<<numBuffers)-1)) { 
 // We ran out of buffers. 
 return -ENOMEM; 
 } 
  
// create a "fake" handles for it 
 intptr_t vaddr = intptr_t(m->framebuffer->base); 
 private_handle_t* hnd = new private_handle_t(dup(m->framebuffer->fd), size, 
 private_handle_t::PRIV_FLAGS_FRAMEBUFFER); 
  
// find a free slot 
 for (uint32_t i=0 ; i<numBuffers ; i++) { 
 if ((bufferMask & (1LU<<i)) == 0) { 
 m->bufferMask |= (1LU<<i); 
 break; 
 } 
 vaddr += bufferSize; 
 } 
  
 hnd->base = vaddr; 
 hnd->offset = vaddr - intptr_t(m->framebuffer->base); 
 *pHandle = hnd; 
  
return 0; 
} 

变量bufferMask用来描述系统帧缓冲区的使用情况，而变量numBuffers用来描述系统帧缓冲区可以划分为多少个图形缓冲区来使用，另外一个变量bufferSize用来描述设备显示屏一屏内容所占用的内存的大小。如果系统帧缓冲区只有一个图形缓冲区大小，即变量numBuffers的值等于1，那么这个图形缓冲区就始终用作系统主图形缓冲区来使用。在这种情况下，我们就不能够在系统帧缓冲区中分配图形缓冲区来给用户空间的应用程序使用，因此，这时候就会转向内存中来分配图形缓冲区，即调用函数gralloc_alloc_buffer来分配图形缓冲区。注意，这时候分配的图形缓冲区的大小为一屏内容的大小，即bufferSize。

如果bufferMask的值大于等于((1LU<<numBuffers)-1)的值，那么就说明系统帧缓冲区中的图形缓冲区全部都分配出去了，这时候分配图形缓冲区就失败了。例如，假设图形缓冲区的个数为2，那么((1LU<<numBuffers)-1)的值就等于3，即二制制0x11。如果这时候bufferMask的值也等于0x11，那么就表示***个和第二个图形缓冲区都已经分配出去了。因此，这时候就不能再在系统帧缓冲区中分配图形缓冲区。

假设此时系统帧缓冲区中尚有空闲的图形缓冲区的，接下来函数就会创建一个private_handle_t结构体hnd来描述这个即将要分配出去的图形缓冲区。注意，这个图形缓冲区的标志值等于PRIV_FLAGS_FRAMEBUFFER，即表示这是一块在系统帧缓冲区中分配的图形缓冲区。

接下来的for循环从低位到高位检查变量bufferMask的值，并且找到***个值等于0的位，这样就可以知道在系统帧缓冲区中，第几个图形缓冲区的是空闲的。注意，变量vadrr的值开始的时候指向系统帧缓冲区的基地址，在下面的for循环中，每循环一次它的值都会增加bufferSize。从这里就可以看出，每次从系统帧缓冲区中分配出去的图形缓冲区的大小都是刚好等于显示屏一屏内容大小的。***分配出去的图形缓冲区的开始地址就保存在前面所创建的private_handle_t结构体hnd的成员变量base中，这样，用户空间的应用程序就可以直接将要渲染的图形内容拷贝到这个地址上去，这就相当于是直接将图形渲染到系统帧缓冲区中去。

在将private_handle_t结构体hnd返回给调用者之前，还需要设置它的成员变量offset，以便可以知道它所描述的图形缓冲区的起始地址相对于系统帧缓冲区的基地址的偏移量。

gralloc_alloc_buffer（gralloc.cpp）的实现如下：

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); 
err = mapBuffer(module, hnd); 
if (err == 0) { 
*pHandle = hnd; 
} 
} 
  
ALOGE_IF(err, "gralloc failed err=%s", strerror(-err)); 
  
return err; 
} 

它首先调用函数ashmem_create_region来创建一块匿名共享内存，接着再在这块匿名共享内存上分配一个图形缓冲区。注意，这个图形缓冲区也是使用一个private_handle_t结构体来描述的，不过这个图形缓冲区的标志值等于0，以区别于在系统帧缓冲区中分配的图形缓冲区。其中mapBuffer又把hnd所描述的一个图形缓冲区映射到当前进程的地址空间来。

以上内容就是alloc_device_t的相关内容。在private_module_t中有一个registerBuffer的函数指针，此函数是干什么的呢？在Android系统中，所有的图形缓冲区都是由SurfaceFlinger服务分配的，而当一个图形缓冲区被分配的时候，它会同时被映射到请求分配的进程的地址空间去，即分配的过程同时也包含了注册的过程。但是对用户空间的其它的应用程序来说，它们所需要的图形缓冲区是在由SurfaceFlinger服务分配的，因此，当它们得到SurfaceFlinger服务分配的图形缓冲区之后，还需要将这块图形缓冲区映射到自己的地址空间来，以便可以使用这块图形缓冲区。这个映射的过程即为我们接下来要分析的图形缓冲区注册过程。

由于在系统帧缓冲区中分配的图形缓冲区只在SurfaceFlinger服务中使用，而SurfaceFlinger服务在初始化系统帧缓冲区的时候，已经将系统帧缓冲区映射到自己所在的进程中来了，因此，函数gralloc_map如果发现要注册的图形缓冲区是在系统帧缓冲区分配的时候，那么就不需要再执行映射图形缓冲区的操作了。

如果要注册的图形缓冲区是在内存中分配的，即它的标志值flags的PRIV_FLAGS_FRAMEBUFFER位等于1，那么接下来就需要将它映射到当前进程的地址空间来了。由于要注册的图形缓冲区是在文件描述符hnd->fd所描述的一块匿名共享内存中分配的，因此，我们只需要将文件描述符hnd->fd所描述的一块匿名共享内存映射到当前进程的地址空间来，就可以将参数hnd所描述的一个图形缓冲区映射到当前进程的地址空间来。

由于映射文件描述符hnd->fd得到的是一整块匿名共享内存在当前进程地址空间的基地址，而要注册的图形缓冲区可能只占据这块匿名共享内存的某一小部分，因此，我们还需要将要注册的图形缓冲区的在被映射的匿名共享内存中的偏移量hnd->offset加上被映射的匿名共享内存的基地址hnd->base，才可以得到要注册的图形缓冲区在当前进程中的访问地址，这个地址最终又被写入到hnd->base中去。

参考文档：http://blog.csdn.net/luoshengyang/article/details/7747932