/**
* Name of the overlay device to open
*/
-#define OVERLAY_HARDWARE_OVERLAY0 "overlay0"
+#define OVERLAY_HARDWARE_CONTROL "control"
+#define OVERLAY_HARDWARE_DATA "data"
/*****************************************************************************/
OVERLAY_FORMAT_BGRA_8888 = 5,
OVERLAY_FORMAT_YCbCr_422_SP = 0x10,
OVERLAY_FORMAT_YCbCr_420_SP = 0x11,
- OVERLAY_FORMAT_YCbCr_422_P = 0x14,
- OVERLAY_FORMAT_YCbCr_420_P = 0x15
+ OVERLAY_FORMAT_YCbCr_422_I = 0x14,
+ OVERLAY_FORMAT_YCbCr_420_I = 0x15
};
-/* values for rotation */
+/* values for copybit_set_parameter(OVERLAY_TRANSFORM) */
enum {
/* flip source image horizontally */
OVERLAY_TRANSFORM_FLIP_H = 0x01,
/* names for setParameter() */
enum {
+ /* rotation of the source image in degrees (0 to 359) */
OVERLAY_ROTATION_DEG = 1,
+ /* enable or disable dithering */
OVERLAY_DITHER = 3,
+ /* transformation applied (this is a superset of COPYBIT_ROTATION_DEG) */
+ OVERLAY_TRANSFORM = 4,
};
/* enable/disable value setParameter() */
uint32_t reserved_procs[7];
} overlay_t;
+typedef void* overlay_buffer_t;
+
/*****************************************************************************/
/**
* Every device data structure must begin with hw_device_t
* followed by module specific public methods and attributes.
*/
-struct overlay_device_t {
+
+struct overlay_control_device_t {
struct hw_device_t common;
/* get static informations about the capabilities of the overlay engine */
- int (*get)(struct overlay_device_t *dev, int name);
+ int (*get)(struct overlay_control_device_t *dev, int name);
/* creates an overlay matching the given parameters as closely as possible.
* returns an error if no more overlays are available. The actual
* size and format is returned in overlay_t. */
- overlay_t* (*createOverlay)(struct overlay_device_t *dev,
+ overlay_t* (*createOverlay)(struct overlay_control_device_t *dev,
uint32_t w, uint32_t h, int32_t format);
/* destroys an overlay. This call releases all
* resources associated with overlay_t and make it invalid */
- void (*destroyOverlay)(struct overlay_device_t *dev,
+ void (*destroyOverlay)(struct overlay_control_device_t *dev,
overlay_t* overlay);
/* set position and scaling of the given overlay as closely as possible.
* if scaling cannot be performed, overlay must be centered. */
- int (*setPosition)(struct overlay_device_t *dev,
+ int (*setPosition)(struct overlay_control_device_t *dev,
overlay_t* overlay,
int x, int y, uint32_t w, uint32_t h);
/* returns the actual position and size of the overlay */
- int (*getPosition)(struct overlay_device_t *dev,
+ int (*getPosition)(struct overlay_control_device_t *dev,
overlay_t* overlay,
int* x, int* y, uint32_t* w, uint32_t* h);
/* sets configurable parameters for this overlay. returns an error if not
* supported. */
- int (*setParameter)(struct overlay_device_t *dev,
+ int (*setParameter)(struct overlay_control_device_t *dev,
overlay_t* overlay, int param, int value);
+};
+
+
+struct overlay_data_device_t {
+ struct hw_device_t common;
+
+ /* initialize the overlay from the given handle. this associates this
+ * overlay data module to its control module */
+ int (*initialize)(struct overlay_data_device_t *dev,
+ overlay_handle_t const* handle);
- /* swaps overlay buffers for double-buffered overlay. the actual swap is
- * synchronized with VSYNC. Typically, this function blocks until a new
- * buffer is available. */
- int (*swapBuffers)(struct overlay_device_t *dev,
- overlay_t* overlay);
-
- /* returns the offset in bytes of the current available buffer. When this
- * function returns, the buffer is ready to be used immediately. Typically,
- * this function blocks until a buffer is available. */
- int (*getOffset)(struct overlay_device_t *dev,
- overlay_t* overlay);
-
- /* returns a filedescriptor that can be used to mmap() the overlay's
- * memory. If this feature is not supported, an error is returned. */
- int (*getMemory)(struct overlay_device_t *dev);
+ /* blocks until an overlay buffer is available and return that buffer. */
+ overlay_buffer_t (*dequeueBuffer)(struct overlay_data_device_t *dev);
+
+ /* release the overlay buffer and post it */
+ int (*queueBuffer)(struct overlay_data_device_t *dev,
+ overlay_buffer_t buffer);
+
+ /* returns the address of a given buffer if supported, NULL otherwise. */
+ void* (*getBufferAddress)(struct overlay_data_device_t *dev,
+ overlay_buffer_t buffer);
};
+
/*****************************************************************************/
/** convenience API for opening and closing a device */
-static inline int overlay_open(const struct hw_module_t* module,
- struct overlay_device_t** device) {
+static inline int overlay_control_open(const struct hw_module_t* module,
+ struct overlay_control_device_t** device) {
return module->methods->open(module,
- OVERLAY_HARDWARE_OVERLAY0, (struct hw_device_t**)device);
+ OVERLAY_HARDWARE_CONTROL, (struct hw_device_t**)device);
}
-static inline int overlay_close(struct overlay_device_t* device) {
+static inline int overlay_control_close(struct overlay_control_device_t* device) {
return device->common.close(&device->common);
}
+static inline int overlay_data_open(const struct hw_module_t* module,
+ struct overlay_data_device_t** device) {
+ return module->methods->open(module,
+ OVERLAY_HARDWARE_DATA, (struct hw_device_t**)device);
+}
+
+static inline int overlay_data_close(struct overlay_data_device_t* device) {
+ return device->common.close(&device->common);
+}
__END_DECLS
/*****************************************************************************/
-struct overlay_context_t {
- struct overlay_device_t device;
+struct overlay_control_context_t {
+ struct overlay_control_device_t device;
/* our private state goes below here */
};
+struct overlay_data_context_t {
+ struct overlay_data_device_t device;
+ /* our private state goes below here */
+};
static int overlay_device_open(const struct hw_module_t* module, const char* name,
struct hw_device_t** device);
}
};
-/*****************************************************************************/
+// ****************************************************************************
+// Control module
+// ****************************************************************************
-static int overlay_get(struct overlay_device_t *dev, int name) {
+static int overlay_get(struct overlay_control_device_t *dev, int name) {
int result = -1;
switch (name) {
case OVERLAY_MINIFICATION_LIMIT:
return result;
}
-static overlay_t* overlay_createOverlay(struct overlay_device_t *dev,
+static overlay_t* overlay_createOverlay(struct overlay_control_device_t *dev,
uint32_t w, uint32_t h, int32_t format)
{
/* check the input params, reject if not supported or invalid */
case OVERLAY_FORMAT_BGRA_8888:
case OVERLAY_FORMAT_YCbCr_422_SP:
case OVERLAY_FORMAT_YCbCr_420_SP:
- case OVERLAY_FORMAT_YCbCr_422_P:
- case OVERLAY_FORMAT_YCbCr_420_P:
+ case OVERLAY_FORMAT_YCbCr_422_I:
+ case OVERLAY_FORMAT_YCbCr_420_I:
break;
default:
return NULL;
return new overlay_object( /* pass needed params here*/ );
}
-static void overlay_destroyOverlay(struct overlay_device_t *dev,
+static void overlay_destroyOverlay(struct overlay_control_device_t *dev,
overlay_t* overlay)
{
/* free resources associated with this overlay_t */
delete overlay;
}
-static int overlay_setPosition(struct overlay_device_t *dev,
+static int overlay_setPosition(struct overlay_control_device_t *dev,
overlay_t* overlay,
int x, int y, uint32_t w, uint32_t h) {
/* set this overlay's position (talk to the h/w) */
return -EINVAL;
}
-static int overlay_getPosition(struct overlay_device_t *dev,
+static int overlay_getPosition(struct overlay_control_device_t *dev,
overlay_t* overlay,
int* x, int* y, uint32_t* w, uint32_t* h) {
/* get this overlay's position */
return -EINVAL;
}
-static int overlay_setParameter(struct overlay_device_t *dev,
+static int overlay_setParameter(struct overlay_control_device_t *dev,
overlay_t* overlay, int param, int value) {
int result = 0;
/* set this overlay's parameter (talk to the h/w) */
switch (param) {
- case OVERLAY_ROTATION_DEG:
+ case OVERLAY_ROTATION_DEG:
+ /* if only 90 rotations are supported, the call fails
+ * for other values */
break;
case OVERLAY_DITHER:
break;
+ case OVERLAY_TRANSFORM:
+ // see OVERLAY_TRANSFORM_*
+ break;
default:
result = -EINVAL;
break;
}
return result;
}
-
-static int overlay_swapBuffers(struct overlay_device_t *dev,
- overlay_t* overlay) {
- /* swap this overlay's buffers (talk to the h/w), this call probably
- * wants to block until a new buffer is available */
- return -EINVAL;
-}
-
-static int overlay_getOffset(struct overlay_device_t *dev,
- overlay_t* overlay) {
- /* return the current's buffer offset */
+
+static int overlay_control_close(struct hw_device_t *dev)
+{
+ struct overlay_control_context_t* ctx = (struct overlay_control_context_t*)dev;
+ if (ctx) {
+ /* free all resources associated with this device here
+ * in particular the overlay_handle_t, outstanding overlay_t, etc...
+ */
+ free(ctx);
+ }
return 0;
}
-static int overlay_getMemory(struct overlay_device_t *dev) {
- /* maps this overlay if possible. don't forget to unmap in destroyOverlay */
+// ****************************************************************************
+// Data module
+// ****************************************************************************
+
+int overlay_initialize(struct overlay_data_device_t *dev,
+ overlay_handle_t const* handle)
+{
+ /*
+ * overlay_handle_t should contain all the information to "inflate" this
+ * overlay. Typically it'll have a file descriptor, informations about
+ * how many buffers are there, etc...
+ * It is also the place to mmap all buffers associated with this overlay
+ * (see getBufferAddress).
+ *
+ * NOTE: this function doesn't take ownership of overlay_handle_t
+ *
+ */
+
return -EINVAL;
}
-/*****************************************************************************/
+overlay_buffer_t overlay_dequeueBuffer(struct overlay_data_device_t *dev)
+{
+ /* blocks until a buffer is available and return an opaque structure
+ * representing this buffer.
+ */
+ return NULL;
+}
+int overlay_queueBuffer(struct overlay_data_device_t *dev,
+ overlay_buffer_t buffer)
+{
+ /* Mark this buffer for posting and recycle or free overlay_buffer_t. */
+ return -EINVAL;
+}
-static int overlay_device_close(struct hw_device_t *dev)
+void *overlay_getBufferAddress(struct overlay_data_device_t *dev,
+ overlay_buffer_t buffer)
{
- struct overlay_context_t* ctx = (struct overlay_context_t*)dev;
+ /* this may fail (NULL) if this feature is not supported. In that case,
+ * presumably, there is some other HAL module that can fill the buffer,
+ * using a DSP for instance */
+ return NULL;
+}
+
+static int overlay_data_close(struct hw_device_t *dev)
+{
+ struct overlay_data_context_t* ctx = (struct overlay_data_context_t*)dev;
if (ctx) {
- /* free all resources associated with this device here */
+ /* free all resources associated with this device here
+ * in particular all pending overlay_buffer_t if needed.
+ *
+ * NOTE: overlay_handle_t passed in initialize() is NOT freed and
+ * its file descriptors are not closed (this is the responsibility
+ * of the caller).
+ */
free(ctx);
}
return 0;
}
+/*****************************************************************************/
static int overlay_device_open(const struct hw_module_t* module, const char* name,
struct hw_device_t** device)
{
int status = -EINVAL;
- if (!strcmp(name, OVERLAY_HARDWARE_OVERLAY0)) {
- struct overlay_context_t *dev;
- dev = (overlay_context_t*)malloc(sizeof(*dev));
+ if (!strcmp(name, OVERLAY_HARDWARE_CONTROL)) {
+ struct overlay_control_context_t *dev;
+ dev = (overlay_control_context_t*)malloc(sizeof(*dev));
/* initialize our state here */
memset(dev, 0, sizeof(*dev));
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 = overlay_device_close;
+ dev->device.common.close = overlay_control_close;
dev->device.get = overlay_get;
dev->device.createOverlay = overlay_createOverlay;
dev->device.setPosition = overlay_setPosition;
dev->device.getPosition = overlay_getPosition;
dev->device.setParameter = overlay_setParameter;
- dev->device.swapBuffers = overlay_swapBuffers;
- dev->device.getOffset = overlay_getOffset;
- dev->device.getMemory = overlay_getMemory;
*device = &dev->device.common;
status = 0;
+ } else if (!strcmp(name, OVERLAY_HARDWARE_DATA)) {
+ struct overlay_data_context_t *dev;
+ dev = (overlay_data_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 = overlay_data_close;
+
+ dev->device.initialize = overlay_initialize;
+ dev->device.dequeueBuffer = overlay_dequeueBuffer;
+ dev->device.queueBuffer = overlay_queueBuffer;
+ dev->device.getBufferAddress = overlay_getBufferAddress;
+
+ *device = &dev->device.common;
+ status = 0;
}
return status;
}
OSDN Git Service
