emulator opengl: first commit of gralloc implementation.
This is the emulator opengl implementation of gralloc. NOTE that it is currently build only if BUILD_EMULATOR_OPENGL_DRIVER is defined, This is because the other driver peices (EGL/GLES) are still missing. Change-Id: If48f5ed619df6efb00cb4e590d99ce49d87875f6
This commit is contained in:
Guy Zadikario
774
tools/emulator/opengl/system/gralloc/gralloc.cpp
Normal file
774
tools/emulator/opengl/system/gralloc/gralloc.cpp
Normal file
@@ -0,0 +1,774 @@
|
||||
/*
|
||||
* Copyright (C) 2011 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#include <hardware/hardware.h>
|
||||
#include <hardware/gralloc.h>
|
||||
#include <cutils/native_handle.h>
|
||||
#include <pthread.h>
|
||||
#ifdef HAVE_ANDROID_OS // just want PAGE_SIZE define
|
||||
# include <asm/page.h>
|
||||
#else
|
||||
# include <sys/user.h>
|
||||
#endif
|
||||
#include <cutils/ashmem.h>
|
||||
#include <unistd.h>
|
||||
#include <errno.h>
|
||||
#include <sys/mman.h>
|
||||
#include "HostConnection.h"
|
||||
#include "glUtils.h"
|
||||
#include <cutils/log.h>
|
||||
|
||||
#define BUFFER_HANDLE_MAGIC ((int)0xabfabfab)
|
||||
|
||||
//
|
||||
// our private gralloc module structure
|
||||
//
|
||||
struct private_module_t {
|
||||
gralloc_module_t base;
|
||||
};
|
||||
|
||||
typedef struct _alloc_list_node {
|
||||
buffer_handle_t handle;
|
||||
_alloc_list_node *next;
|
||||
_alloc_list_node *prev;
|
||||
} AllocListNode;
|
||||
|
||||
//
|
||||
// Our gralloc device structure (alloc interface)
|
||||
//
|
||||
struct gralloc_device_t {
|
||||
alloc_device_t device;
|
||||
|
||||
AllocListNode *allocListHead; // double linked list of allocated buffers
|
||||
pthread_mutex_t lock;
|
||||
};
|
||||
|
||||
//
|
||||
// Our framebuffer device structure
|
||||
//
|
||||
struct fb_device_t {
|
||||
framebuffer_device_t device;
|
||||
};
|
||||
|
||||
#define CB_HANDLE_NUM_INTS(nfds) ((sizeof(cb_handle_t) - (nfds)*sizeof(int)) / sizeof(int))
|
||||
|
||||
//
|
||||
// Our buffer handle structure
|
||||
//
|
||||
struct cb_handle_t : public native_handle {
|
||||
|
||||
cb_handle_t(int p_fd, int p_ashmemSize, int p_usage,
|
||||
int p_width, int p_height, int p_glFormat) :
|
||||
fd(p_fd),
|
||||
magic(BUFFER_HANDLE_MAGIC),
|
||||
usage(p_usage),
|
||||
width(p_width),
|
||||
height(p_height),
|
||||
glFormat(p_glFormat),
|
||||
ashmemSize(p_ashmemSize),
|
||||
ashmemBase(NULL),
|
||||
ashmemBasePid(0),
|
||||
mappedPid(0),
|
||||
lockedLeft(0),
|
||||
lockedTop(0),
|
||||
lockedWidth(0),
|
||||
lockedHeight(0),
|
||||
hostHandle(0)
|
||||
{
|
||||
version = sizeof(native_handle);
|
||||
numFds = 1;
|
||||
numInts = CB_HANDLE_NUM_INTS(numFds);
|
||||
}
|
||||
|
||||
~cb_handle_t() {
|
||||
magic = 0;
|
||||
}
|
||||
|
||||
bool validate() const {
|
||||
return (version == sizeof(native_handle) &&
|
||||
magic == BUFFER_HANDLE_MAGIC &&
|
||||
numInts == CB_HANDLE_NUM_INTS(1) &&
|
||||
numFds == 1);
|
||||
}
|
||||
|
||||
bool canBePosted() {
|
||||
return (0 != (usage & GRALLOC_USAGE_HW_FB));
|
||||
}
|
||||
|
||||
// file-descriptors
|
||||
int fd; // ashmem fd (-1 of ashmem region did not allocated, i.e. no SW access needed)
|
||||
|
||||
// ints
|
||||
int magic; // magic number in order to validate a pointer to be a cb_handle_t
|
||||
int usage; // usage bits the buffer was created with
|
||||
int width; // buffer width
|
||||
int height; // buffer height
|
||||
int glFormat; // OpenGL format enum used for host h/w color buffer
|
||||
int ashmemSize; // ashmem region size for the buffer (0 unless is HW_FB buffer or
|
||||
// s/w access is needed)
|
||||
int ashmemBase; // CPU address of the mapped ashmem region
|
||||
int ashmemBasePid; // process id which mapped the ashmem region
|
||||
int mappedPid; // process id which succeeded gralloc_register call
|
||||
int lockedLeft; // region of buffer locked for s/w write
|
||||
int lockedTop;
|
||||
int lockedWidth;
|
||||
int lockedHeight;
|
||||
uint32_t hostHandle;
|
||||
};
|
||||
|
||||
static int map_buffer(cb_handle_t *cb, void **vaddr)
|
||||
{
|
||||
if (cb->fd < 0 || cb->ashmemSize <= 0) {
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
void *addr = mmap(0, cb->ashmemSize, PROT_READ | PROT_WRITE,
|
||||
MAP_SHARED, cb->fd, 0);
|
||||
if (addr == MAP_FAILED) {
|
||||
return -errno;
|
||||
}
|
||||
|
||||
cb->ashmemBase = intptr_t(addr);
|
||||
cb->ashmemBasePid = getpid();
|
||||
|
||||
*vaddr = addr;
|
||||
return 0;
|
||||
}
|
||||
|
||||
#define DEFINE_HOST_CONNECTION \
|
||||
HostConnection *hostCon = HostConnection::get(); \
|
||||
renderControl_encoder_context_t *rcEnc = (hostCon ? hostCon->rcEncoder() : NULL)
|
||||
|
||||
#define DEFINE_AND_VALIDATE_HOST_CONNECTION \
|
||||
HostConnection *hostCon = HostConnection::get(); \
|
||||
if (!hostCon) { \
|
||||
LOGE("gralloc: Failed to get host connection\n"); \
|
||||
return -EIO; \
|
||||
} \
|
||||
renderControl_encoder_context_t *rcEnc = hostCon->rcEncoder(); \
|
||||
if (!rcEnc) { \
|
||||
LOGE("gralloc: Failed to get renderControl encoder context\n"); \
|
||||
return -EIO; \
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// gralloc device functions (alloc interface)
|
||||
//
|
||||
static int gralloc_alloc(alloc_device_t* dev,
|
||||
int w, int h, int format, int usage,
|
||||
buffer_handle_t* pHandle, int* pStride)
|
||||
{
|
||||
LOGD("gralloc_alloc w=%d h=%d usage=0x%x\n", w, h, usage);
|
||||
|
||||
gralloc_device_t *grdev = (gralloc_device_t *)dev;
|
||||
if (!grdev || !pHandle || !pStride)
|
||||
return -EINVAL;
|
||||
|
||||
//
|
||||
// Validate usage: buffer cannot be written both by s/w and h/w access.
|
||||
//
|
||||
bool sw_write = (0 != (usage & GRALLOC_USAGE_SW_WRITE_MASK));
|
||||
bool hw_write = (usage & GRALLOC_USAGE_HW_RENDER);
|
||||
if (hw_write && sw_write) {
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
int ashmem_size = 0;
|
||||
*pStride = 0;
|
||||
GLenum glFormat = 0;
|
||||
|
||||
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;
|
||||
glFormat = GL_RGBA;
|
||||
break;
|
||||
case HAL_PIXEL_FORMAT_RGB_888:
|
||||
bpp = 3;
|
||||
glFormat = GL_RGB;
|
||||
break;
|
||||
case HAL_PIXEL_FORMAT_RGB_565:
|
||||
bpp = 2;
|
||||
glFormat = GL_RGB565_OES;
|
||||
break;
|
||||
case HAL_PIXEL_FORMAT_RGBA_5551:
|
||||
bpp = 2;
|
||||
glFormat = GL_RGB5_A1_OES;
|
||||
break;
|
||||
case HAL_PIXEL_FORMAT_RGBA_4444:
|
||||
bpp = 2;
|
||||
glFormat = GL_RGBA4_OES;
|
||||
break;
|
||||
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (usage & GRALLOC_USAGE_HW_FB) {
|
||||
// keep space for postCounter
|
||||
ashmem_size += sizeof(uint32_t);
|
||||
}
|
||||
|
||||
if (usage & (GRALLOC_USAGE_SW_READ_MASK | GRALLOC_USAGE_SW_WRITE_MASK)) {
|
||||
// keep space for image on guest memory if SW access is needed
|
||||
int align = 1;
|
||||
size_t bpr = (w*bpp + (align-1)) & ~(align-1);
|
||||
ashmem_size += (bpr * h);
|
||||
*pStride = bpr / bpp;
|
||||
}
|
||||
|
||||
LOGD("gralloc_alloc ashmem_size=%d\n", ashmem_size);
|
||||
|
||||
//
|
||||
// Allocate space in ashmem if needed
|
||||
//
|
||||
int fd = -1;
|
||||
if (ashmem_size > 0) {
|
||||
// round to page size;
|
||||
ashmem_size = (ashmem_size + (PAGE_SIZE-1)) & ~(PAGE_SIZE-1);
|
||||
|
||||
fd = ashmem_create_region("gralloc-buffer", ashmem_size);
|
||||
if (fd < 0) {
|
||||
LOGE("gralloc_alloc failed to create ashmem region err=%d\n", errno);
|
||||
return -errno;
|
||||
}
|
||||
}
|
||||
|
||||
cb_handle_t *cb = new cb_handle_t(fd, ashmem_size, usage, w, h, glFormat);
|
||||
|
||||
if (ashmem_size > 0) {
|
||||
//
|
||||
// map ashmem region if exist
|
||||
//
|
||||
void *vaddr;
|
||||
int err = map_buffer(cb, &vaddr);
|
||||
if (err) {
|
||||
close(fd);
|
||||
delete cb;
|
||||
return err;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Allocate ColorBuffer handle on the host (only if h/w access is allowed)
|
||||
//
|
||||
if (usage & GRALLOC_USAGE_HW_MASK) {
|
||||
DEFINE_HOST_CONNECTION;
|
||||
if (hostCon && rcEnc) {
|
||||
cb->hostHandle = rcEnc->rcCreateColorBuffer(rcEnc, w, h, glFormat);
|
||||
LOGD("Created host ColorBuffer 0x%x\n", cb->hostHandle);
|
||||
}
|
||||
|
||||
if (!cb->hostHandle) {
|
||||
// Could not create colorbuffer on host !!!
|
||||
close(fd);
|
||||
delete cb;
|
||||
return -EIO;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// alloc succeeded - insert the allocated handle to the allocated list
|
||||
//
|
||||
AllocListNode *node = new AllocListNode();
|
||||
pthread_mutex_lock(&grdev->lock);
|
||||
node->handle = cb;
|
||||
node->next = grdev->allocListHead;
|
||||
node->prev = NULL;
|
||||
if (grdev->allocListHead) {
|
||||
grdev->allocListHead->prev = node;
|
||||
}
|
||||
grdev->allocListHead = node;
|
||||
pthread_mutex_unlock(&grdev->lock);
|
||||
|
||||
*pHandle = cb;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int gralloc_free(alloc_device_t* dev,
|
||||
buffer_handle_t handle)
|
||||
{
|
||||
const cb_handle_t *cb = (const cb_handle_t *)handle;
|
||||
if (!cb || !cb->validate()) {
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (cb->hostHandle != 0) {
|
||||
DEFINE_AND_VALIDATE_HOST_CONNECTION;
|
||||
|
||||
rcEnc->rcDestroyColorBuffer(rcEnc, cb->hostHandle);
|
||||
}
|
||||
|
||||
//
|
||||
// detach and unmap ashmem area if present
|
||||
//
|
||||
if (cb->fd > 0) {
|
||||
if (cb->ashmemSize > 0 && cb->ashmemBase) {
|
||||
munmap((void *)cb->ashmemBase, cb->ashmemSize);
|
||||
}
|
||||
close(cb->fd);
|
||||
}
|
||||
|
||||
// remove it from the allocated list
|
||||
gralloc_device_t *grdev = (gralloc_device_t *)dev;
|
||||
pthread_mutex_lock(&grdev->lock);
|
||||
AllocListNode *n = grdev->allocListHead;
|
||||
while( n && n->handle != cb ) {
|
||||
n = n->next;
|
||||
}
|
||||
if (n) {
|
||||
// buffer found on list - remove it from list
|
||||
if (n->next) {
|
||||
n->next->prev = n->prev;
|
||||
}
|
||||
if (n->prev) {
|
||||
n->prev = n->next;
|
||||
}
|
||||
else {
|
||||
grdev->allocListHead = n->next;
|
||||
}
|
||||
|
||||
delete n;
|
||||
}
|
||||
pthread_mutex_unlock(&grdev->lock);
|
||||
|
||||
delete cb;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int gralloc_device_close(struct hw_device_t *dev)
|
||||
{
|
||||
gralloc_device_t* d = reinterpret_cast<gralloc_device_t*>(dev);
|
||||
if (d) {
|
||||
|
||||
// free still allocated buffers
|
||||
while( d->allocListHead != NULL ) {
|
||||
gralloc_free(&d->device, d->allocListHead->handle);
|
||||
}
|
||||
|
||||
// free device
|
||||
free(d);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
//
|
||||
// Framebuffer device functions
|
||||
//
|
||||
static int fb_post(struct framebuffer_device_t* dev, buffer_handle_t buffer)
|
||||
{
|
||||
fb_device_t *fbdev = (fb_device_t *)dev;
|
||||
cb_handle_t *cb = (cb_handle_t *)buffer;
|
||||
|
||||
if (!fbdev || !cb || !cb->validate() || !cb->canBePosted()) {
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
// Make sure we have host connection
|
||||
DEFINE_AND_VALIDATE_HOST_CONNECTION;
|
||||
|
||||
// increment the post count of the buffer
|
||||
uint32_t *postCountPtr = (uint32_t *)cb->ashmemBase;
|
||||
if (!postCountPtr) {
|
||||
// This should not happen
|
||||
return -EINVAL;
|
||||
}
|
||||
(*postCountPtr)++;
|
||||
|
||||
// send post request to host
|
||||
rcEnc->rcFBPost(rcEnc, cb->hostHandle);
|
||||
hostCon->flush();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int fb_setUpdateRect(struct framebuffer_device_t* dev,
|
||||
int l, int t, int w, int h)
|
||||
{
|
||||
fb_device_t *fbdev = (fb_device_t *)dev;
|
||||
|
||||
if (!fbdev) {
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
// Make sure we have host connection
|
||||
DEFINE_AND_VALIDATE_HOST_CONNECTION;
|
||||
|
||||
// send request to host
|
||||
// XXX - should be implemented
|
||||
//rcEnc->rc_XXX
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int fb_setSwapInterval(struct framebuffer_device_t* dev,
|
||||
int interval)
|
||||
{
|
||||
fb_device_t *fbdev = (fb_device_t *)dev;
|
||||
|
||||
if (!fbdev) {
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
// Make sure we have host connection
|
||||
DEFINE_AND_VALIDATE_HOST_CONNECTION;
|
||||
|
||||
// send request to host
|
||||
rcEnc->rcFBSetSwapInterval(rcEnc, interval);
|
||||
hostCon->flush();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int fb_close(struct hw_device_t *dev)
|
||||
{
|
||||
fb_device_t *fbdev = (fb_device_t *)dev;
|
||||
|
||||
if (fbdev) {
|
||||
delete fbdev;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// gralloc module functions - refcount + locking interface
|
||||
//
|
||||
static int gralloc_register_buffer(gralloc_module_t const* module,
|
||||
buffer_handle_t handle)
|
||||
{
|
||||
private_module_t *gr = (private_module_t *)module;
|
||||
cb_handle_t *cb = (cb_handle_t *)handle;
|
||||
if (!gr || !cb || !cb->validate()) {
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
//
|
||||
// if the color buffer has ashmem region and it is not mapped in this
|
||||
// process map it now.
|
||||
//
|
||||
if (cb->ashmemSize > 0 && cb->mappedPid != getpid()) {
|
||||
void *vaddr;
|
||||
int err = map_buffer(cb, &vaddr);
|
||||
if (err) {
|
||||
return -err;
|
||||
}
|
||||
cb->mappedPid = getpid();
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int gralloc_unregister_buffer(gralloc_module_t const* module,
|
||||
buffer_handle_t handle)
|
||||
{
|
||||
private_module_t *gr = (private_module_t *)module;
|
||||
cb_handle_t *cb = (cb_handle_t *)handle;
|
||||
if (!gr || !cb || !cb->validate()) {
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
//
|
||||
// unmap ashmem region if it was previously mapped in this process
|
||||
// (through register_buffer)
|
||||
//
|
||||
if (cb->ashmemSize > 0 && cb->mappedPid == getpid()) {
|
||||
void *vaddr;
|
||||
int err = munmap((void *)cb->ashmemBase, cb->ashmemSize);
|
||||
if (err) {
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int gralloc_lock(gralloc_module_t const* module,
|
||||
buffer_handle_t handle, int usage,
|
||||
int l, int t, int w, int h,
|
||||
void** vaddr)
|
||||
{
|
||||
private_module_t *gr = (private_module_t *)module;
|
||||
cb_handle_t *cb = (cb_handle_t *)handle;
|
||||
if (!gr || !cb || !cb->validate()) {
|
||||
LOGE("gralloc_lock bad handle\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
// Validate usage,
|
||||
// 1. cannot be locked for hw access
|
||||
// 2. lock for either sw read or write.
|
||||
// 3. locked sw access must match usage during alloc time.
|
||||
bool sw_read = (0 != (usage & GRALLOC_USAGE_SW_READ_MASK));
|
||||
bool sw_write = (0 != (usage & GRALLOC_USAGE_SW_WRITE_MASK));
|
||||
bool hw_read = (usage & GRALLOC_USAGE_HW_TEXTURE);
|
||||
bool hw_write = (usage & GRALLOC_USAGE_HW_RENDER);
|
||||
bool sw_read_allowed = (0 != (cb->usage & GRALLOC_USAGE_SW_READ_MASK));
|
||||
bool sw_write_allowed = (0 != (cb->usage & GRALLOC_USAGE_SW_WRITE_MASK));
|
||||
|
||||
if ( (hw_read || hw_write) ||
|
||||
(!sw_read && !sw_write) ||
|
||||
(sw_read && !sw_read_allowed) ||
|
||||
(sw_write && !sw_write_allowed) ) {
|
||||
LOGE("gralloc_lock usage mismatch usage=0x%x cb->usage=0x%x\n", usage, cb->usage);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
EGLint postCount = 0;
|
||||
void *cpu_addr = NULL;
|
||||
|
||||
//
|
||||
// make sure ashmem area is mapped if needed
|
||||
//
|
||||
if (cb->canBePosted() || sw_read || sw_write) {
|
||||
if (cb->ashmemBasePid != getpid() || !cb->ashmemBase) {
|
||||
return -EACCES;
|
||||
}
|
||||
|
||||
if (cb->canBePosted()) {
|
||||
postCount = *((int *)cb->ashmemBase);
|
||||
cpu_addr = (void *)(cb->ashmemBase + sizeof(int));
|
||||
}
|
||||
else {
|
||||
cpu_addr = (void *)(cb->ashmemBase);
|
||||
}
|
||||
}
|
||||
|
||||
if (cb->hostHandle) {
|
||||
// Make sure we have host connection
|
||||
DEFINE_AND_VALIDATE_HOST_CONNECTION;
|
||||
|
||||
//
|
||||
// flush color buffer write cache on host and get its sync status.
|
||||
//
|
||||
int hostSyncStatus = rcEnc->rcColorBufferCacheFlush(rcEnc, cb->hostHandle,
|
||||
postCount,
|
||||
sw_read);
|
||||
if (hostSyncStatus < 0) {
|
||||
// host failed the color buffer sync - probably since it was already
|
||||
// locked for write access. fail the lock.
|
||||
LOGE("gralloc_lock cacheFlush failed postCount=%d sw_read=%d\n",
|
||||
postCount, sw_read);
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
//
|
||||
// is virtual address required ?
|
||||
//
|
||||
if (sw_read || sw_write) {
|
||||
*vaddr = cpu_addr;
|
||||
}
|
||||
}
|
||||
|
||||
if (sw_write) {
|
||||
//
|
||||
// Keep locked region if locked for s/w write access.
|
||||
//
|
||||
cb->lockedLeft = l;
|
||||
cb->lockedTop = t;
|
||||
cb->lockedWidth = w;
|
||||
cb->lockedHeight = h;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int gralloc_unlock(gralloc_module_t const* module,
|
||||
buffer_handle_t handle)
|
||||
{
|
||||
private_module_t *gr = (private_module_t *)module;
|
||||
cb_handle_t *cb = (cb_handle_t *)handle;
|
||||
if (!gr || !cb || !cb->validate()) {
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
//
|
||||
// if buffer was locked for s/w write, we need to update the host with
|
||||
// the updated data
|
||||
//
|
||||
if (cb->lockedWidth > 0 && cb->lockedHeight > 0 && cb->hostHandle) {
|
||||
|
||||
// Make sure we have host connection
|
||||
DEFINE_AND_VALIDATE_HOST_CONNECTION;
|
||||
|
||||
void *cpu_addr;
|
||||
if (cb->canBePosted()) {
|
||||
cpu_addr = (void *)(cb->ashmemBase + sizeof(int));
|
||||
}
|
||||
else {
|
||||
cpu_addr = (void *)(cb->ashmemBase);
|
||||
}
|
||||
|
||||
if (cb->lockedWidth < cb->width || cb->lockedHeight < cb->height) {
|
||||
int bpp = glUtilsPixelBitSize(cb->glFormat, GL_UNSIGNED_BYTE) >> 3;
|
||||
char *tmpBuf = new char[cb->lockedWidth * cb->lockedHeight * bpp];
|
||||
|
||||
int dst_line_len = cb->lockedWidth * bpp;
|
||||
int src_line_len = cb->width * bpp;
|
||||
char *src = (char *)cpu_addr + cb->lockedTop*src_line_len + cb->lockedLeft*bpp;
|
||||
char *dst = tmpBuf;
|
||||
for (int y=0; y<cb->lockedHeight; y++) {
|
||||
memcpy(dst, src, dst_line_len);
|
||||
src += src_line_len;
|
||||
dst += dst_line_len;
|
||||
}
|
||||
|
||||
rcEnc->rcUpdateColorBuffer(rcEnc, cb->hostHandle,
|
||||
cb->lockedLeft, cb->lockedTop,
|
||||
cb->lockedWidth, cb->lockedHeight,
|
||||
cb->glFormat, GL_UNSIGNED_BYTE,
|
||||
tmpBuf);
|
||||
|
||||
delete [] tmpBuf;
|
||||
}
|
||||
else {
|
||||
rcEnc->rcUpdateColorBuffer(rcEnc, cb->hostHandle, 0, 0,
|
||||
cb->width, cb->height,
|
||||
cb->glFormat, GL_UNSIGNED_BYTE,
|
||||
cpu_addr);
|
||||
}
|
||||
}
|
||||
|
||||
cb->lockedWidth = cb->lockedHeight = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int gralloc_device_open(const hw_module_t* module,
|
||||
const char* name,
|
||||
hw_device_t** device)
|
||||
{
|
||||
int status = -EINVAL;
|
||||
|
||||
LOGD("gralloc_device_open %s\n", name);
|
||||
|
||||
if (!strcmp(name, GRALLOC_HARDWARE_GPU0)) {
|
||||
|
||||
// Create host connection and keep it in the TLS.
|
||||
// return error if connection with host can not be established
|
||||
HostConnection *hostCon = HostConnection::get();
|
||||
if (!hostCon) {
|
||||
LOGE("gralloc: failed to get host connection while opening %s\n", name);
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
//
|
||||
// Allocate memory for the gralloc device (alloc interface)
|
||||
//
|
||||
gralloc_device_t *dev;
|
||||
dev = (gralloc_device_t*)malloc(sizeof(gralloc_device_t));
|
||||
if (NULL == dev) {
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
// Initialize our device structure
|
||||
//
|
||||
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_device_close;
|
||||
|
||||
dev->device.alloc = gralloc_alloc;
|
||||
dev->device.free = gralloc_free;
|
||||
dev->allocListHead = NULL;
|
||||
pthread_mutex_init(&dev->lock, NULL);
|
||||
|
||||
*device = &dev->device.common;
|
||||
status = 0;
|
||||
}
|
||||
else if (!strcmp(name, GRALLOC_HARDWARE_FB0)) {
|
||||
|
||||
// return error if connection with host can not be established
|
||||
DEFINE_AND_VALIDATE_HOST_CONNECTION;
|
||||
|
||||
//
|
||||
// Query the host for Framebuffer attributes
|
||||
//
|
||||
LOGD("gralloc: query Frabuffer attribs\n");
|
||||
EGLint width = rcEnc->rcGetFBParam(rcEnc, FB_WIDTH);
|
||||
LOGD("gralloc: width=%d\n", width);
|
||||
EGLint height = rcEnc->rcGetFBParam(rcEnc, FB_HEIGHT);
|
||||
LOGD("gralloc: height=%d\n", height);
|
||||
EGLint xdpi = rcEnc->rcGetFBParam(rcEnc, FB_XDPI);
|
||||
EGLint ydpi = rcEnc->rcGetFBParam(rcEnc, FB_YDPI);
|
||||
EGLint fps = rcEnc->rcGetFBParam(rcEnc, FB_FPS);
|
||||
EGLint min_si = rcEnc->rcGetFBParam(rcEnc, FB_MIN_SWAP_INTERVAL);
|
||||
EGLint max_si = rcEnc->rcGetFBParam(rcEnc, FB_MAX_SWAP_INTERVAL);
|
||||
|
||||
//
|
||||
// Allocate memory for the framebuffer device
|
||||
//
|
||||
fb_device_t *dev;
|
||||
dev = (fb_device_t*)malloc(sizeof(fb_device_t));
|
||||
if (NULL == dev) {
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
// Initialize our device structure
|
||||
//
|
||||
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; //XXX: fb_setUpdateRect;
|
||||
|
||||
const_cast<uint32_t&>(dev->device.flags) = 0;
|
||||
const_cast<uint32_t&>(dev->device.width) = width;
|
||||
const_cast<uint32_t&>(dev->device.height) = height;
|
||||
const_cast<int&>(dev->device.stride) = width;
|
||||
const_cast<int&>(dev->device.format) = HAL_PIXEL_FORMAT_RGBA_8888;
|
||||
const_cast<float&>(dev->device.xdpi) = xdpi;
|
||||
const_cast<float&>(dev->device.ydpi) = ydpi;
|
||||
const_cast<float&>(dev->device.fps) = fps;
|
||||
const_cast<int&>(dev->device.minSwapInterval) = min_si;
|
||||
const_cast<int&>(dev->device.maxSwapInterval) = max_si;
|
||||
*device = &dev->device.common;
|
||||
|
||||
status = 0;
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
//
|
||||
// define the HMI symbol - our module interface
|
||||
//
|
||||
static struct hw_module_methods_t gralloc_module_methods = {
|
||||
open: gralloc_device_open
|
||||
};
|
||||
|
||||
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,
|
||||
}
|
||||
};
|
||||
Reference in New Issue
Block a user