auto import from //branches/cupcake/...@125939

3 files changed, 166 insertions, 72 deletions

diff --git a/include/hardware/AudioHardwareInterface.h b/include/hardware/AudioHardwareInterface.h
index 66cf0ff..610df37 100644
--- a/include/hardware/AudioHardwareInterface.h
+++ b/include/hardware/AudioHardwareInterface.h
@@ -81,6 +81,12 @@ public:
     /** write audio buffer to driver. Returns number of bytes written */
     virtual ssize_t     write(const void* buffer, size_t bytes) = 0;
 
+    /**
+     * Put the audio hardware output into standby mode. Returns
+     * status based on include/utils/Errors.h
+     */
+    virtual status_t    standby() = 0;
+
     /** dump the state of the audio output device */
     virtual status_t dump(int fd, const Vector<String16>& args) = 0;
 };
@@ -150,12 +156,6 @@ public:
      */
     virtual status_t    initCheck() = 0;
 
-    /**
-     * put the audio hardware into standby mode to conserve power. Returns
-     * status based on include/utils/Errors.h
-     */
-    virtual status_t    standby() = 0;
-
     /** set the audio volume of a voice call. Range is between 0.0 and 1.0 */
     virtual status_t    setVoiceVolume(float volume) = 0;
 
diff --git a/include/hardware/overlay.h b/include/hardware/overlay.h
index b798c56..4c2d4c1 100644
--- a/include/hardware/overlay.h
+++ b/include/hardware/overlay.h
@@ -33,7 +33,8 @@ __BEGIN_DECLS
 /**
  * Name of the overlay device to open
  */
-#define OVERLAY_HARDWARE_OVERLAY0 "overlay0"
+#define OVERLAY_HARDWARE_CONTROL    "control"
+#define OVERLAY_HARDWARE_DATA       "data"
 
 /*****************************************************************************/
 
@@ -44,11 +45,11 @@ enum {
     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,
@@ -64,8 +65,12 @@ enum {
 
 /* 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() */
@@ -117,6 +122,8 @@ typedef struct overlay_t {
     uint32_t            reserved_procs[7];
 } overlay_t;
 
+typedef void* overlay_buffer_t;
+
 /*****************************************************************************/
 
 /**
@@ -134,70 +141,86 @@ struct overlay_module_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
 
diff --git a/modules/overlay/overlay.cpp b/modules/overlay/overlay.cpp
index 3e4c02b..4ef7659 100644
--- a/modules/overlay/overlay.cpp
+++ b/modules/overlay/overlay.cpp
@@ -27,11 +27,15 @@
 
 /*****************************************************************************/
 
-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);
@@ -87,9 +91,11 @@ public:
     }
 };
 
-/*****************************************************************************/
+// ****************************************************************************
+// 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:
@@ -120,7 +126,7 @@ static int overlay_get(struct overlay_device_t *dev, int name) {
     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 */
@@ -130,8 +136,8 @@ static overlay_t* overlay_createOverlay(struct overlay_device_t *dev,
         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;
@@ -147,83 +153,131 @@ static overlay_t* overlay_createOverlay(struct overlay_device_t *dev,
     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));
@@ -232,7 +286,7 @@ static int overlay_device_open(const struct hw_module_t* module, const char* nam
         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;
@@ -240,12 +294,29 @@ static int overlay_device_open(const struct hw_module_t* module, const char* nam
         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;
 }