1. static int gralloc_alloc(alloc_device_t* dev,   
2.         int w, int h, int format, int usage,   
3.         buffer_handle_t* pHandle, int* pStride)   
4. {   
5.     if (!pHandle || !pStride)   
6.         return -EINVAL;   
7.    
8.     size_t size, stride;   
9.    
10.     int align = 4;   
11.     int bpp = 0;   
12.     switch (format) {   
13.         case HAL_PIXEL_FORMAT_RGBA_8888:   
14.         case HAL_PIXEL_FORMAT_RGBX_8888:   
15.         case HAL_PIXEL_FORMAT_BGRA_8888:   
16.             bpp = 4;   
17.             break;   
18.         case HAL_PIXEL_FORMAT_RGB_888:   
19.             bpp = 3;   
20.             break;   
21.         case HAL_PIXEL_FORMAT_RGB_565:   
22.         case HAL_PIXEL_FORMAT_RGBA_5551:   
23.         case HAL_PIXEL_FORMAT_RGBA_4444:   
24.             bpp = 2;   
25.             break;   
26.         default:   
27.             return -EINVAL;   
28.     }   
29.     size_t bpr = (w*bpp + (align-1)) & ~(align-1);   
30.     size = bpr * h;   
31.     stride = bpr / bpp;   
32.    
33.     int err;   
34.     if (usage & GRALLOC_USAGE_HW_FB) {   
35.         err = gralloc_alloc_framebuffer(dev, size, usage, pHandle);   
36.     } else {   
37.         err = gralloc_alloc_buffer(dev, size, usage, pHandle);   
38.     }   
39.    
40.     if (err < 0) {   
41.         return err;   
42.     }   
43.    
44.     *pStride = stride;   
45.     return 0;   
46. }   

1. static int gralloc_alloc_framebuffer_locked(alloc_device_t* dev,   
2.         size_t size, int usage, buffer_handle_t* pHandle)   
3. {   
4.     private_module_t* m = reinterpret_cast<private_module_t*>(   
5.             dev->common.module);   
6.    
7.     // allocate the framebuffer   
8.     if (m->framebuffer == NULL) {   
9.         // initialize the framebuffer, the framebuffer is mapped once   
10.         // and forever.   
11.         int err = mapFrameBufferLocked(m);   
12.         if (err < 0) {   
13.             return err;   
14.         }   
15.     }   
16.    
17.     const uint32_t bufferMask = m->bufferMask;   
18.     const uint32_t numBuffers = m->numBuffers;   
19.     const size_t bufferSize = m->finfo.line_length * m->info.yres;   
20.     if (numBuffers == 1) {   
21.         // If we have only one buffer, we never use page-flipping. Instead,   
22.         // we return a regular buffer which will be memcpy'ed to the main   
23.         // screen when post is called.   
24.         int newUsage = (usage & ~GRALLOC_USAGE_HW_FB) | GRALLOC_USAGE_HW_2D;   
25.         return gralloc_alloc_buffer(dev, bufferSize, newUsage, pHandle);   
26.     }   
27.    
28.     if (bufferMask >= ((1LU<<numBuffers)-1)) {   
29.         // We ran out of buffers.   
30.         return -ENOMEM;   
31.     }   
32.    
33.     // create a "fake" handles for it   
34.     intptr_t vaddr = intptr_t(m->framebuffer->base);   
35.     private_handle_t* hnd = new private_handle_t(dup(m->framebuffer->fd), size,   
36.             private_handle_t::PRIV_FLAGS_FRAMEBUFFER);   
37.    
38.     // find a free slot   
39.     for (uint32_t i=0 ; i<numBuffers ; i++) {   
40.         if ((bufferMask & (1LU<<i)) == 0) {   
41.             m->bufferMask |= (1LU<<i);   
42.             break;   
43.         }   
44.         vaddr += bufferSize;   
45.     }   
46.    
47.     hnd->base = vaddr;   
48.     hnd->offset = vaddr - intptr_t(m->framebuffer->base);   
49.     *pHandle = hnd;   
50.    
51.     return 0;   
52. }   

1. static int gralloc_alloc_buffer(alloc_device_t* dev,   
2.         size_t size, int usage, buffer_handle_t* pHandle)   
3. {   
4.     int err = 0;   
5.     int fd = -1;   
6.    
7.     size = roundUpToPageSize(size);   
8.    
9.     fd = ashmem_create_region("gralloc-buffer", size);   
10.     if (fd < 0) {   
11.         LOGE("couldn't create ashmem (%s)", strerror(-errno));   
12.         err = -errno;   
13.     }   
14.    
15.     if (err == 0) {   
16.         private_handle_t* hnd = new private_handle_t(fd, size, 0);   
17.         gralloc_module_t* module = reinterpret_cast<gralloc_module_t*>(   
18.                 dev->common.module);   
19.         err = mapBuffer(module, hnd);   
20.         if (err == 0) {   
21.             *pHandle = hnd;   
22.         }   
23.     }   
24.    
25.     LOGE_IF(err, "gralloc failed err=%s", strerror(-err));   
26.    
27.     return err;   
28. }